For.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7ebba9e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#For laço de repetição\n",
    "#Função range para imprimir os números inteiros de 1 a 10\n",
    "\n",
    "#For - para\n",
    "for numero in range(1, 11):\n",
    "    \n",
    "    print(numero)\n",
    "    \n",
    "\"\"\"\n",
    "Explicação:\n",
    "\n",
    "    Loop For com Range: A estrutura for é usada para criar um loop que \n",
    "    iterará sobre uma sequência de valores. A função range(1, 11) gera uma sequência \n",
    "    de números inteiros começando em 1 e terminando antes de 11.\n",
    "\n",
    "    Corpo do Loop: Dentro do loop, há uma única instrução:\n",
    "    \n",
    "        Imprimir Número Atual: A função print(i) imprime o valor atual da variável de loop i.\n",
    "\n",
    "    Execução do Loop: O loop será executado para cada valor de i na sequência gerada \n",
    "    por range(1, 11), o que significa que ele será executado 10 vezes, com i assumindo os \n",
    "    valores de 1 a 10, um de cada vez.\n",
    "\n",
    "\n",
    "O código ilustra como usar um loop for com a função range para iterar sobre uma sequência \n",
    "de números inteiros, executando uma ação (neste caso, imprimir o número) para cada valor na \n",
    "sequência. É uma maneira comum de repetir uma ação para um número fixo de vezes em Python.\n",
    "\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36199f11",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "37e9072e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "A diferença entre os loops while e for em Python (e na maioria das linguagens de programação) reside \n",
    "principalmente em como eles determinam a continuação do loop e como manipulam a iteração. \n",
    "\n",
    "Veja as principais diferenças:\n",
    "\n",
    "Loop while\n",
    "\n",
    "    Controle de Condição: O loop while continuará executando enquanto uma condição \n",
    "    especificada for avaliada como verdadeira (True).\n",
    "    \n",
    "    Incremento/Decremento Manual: Você geralmente precisa manipular manualmente a \n",
    "    variável de controle (por exemplo, incrementar ou decrementar) dentro do loop.\n",
    "    \n",
    "    Geralmente Usado Quando: A quantidade de iterações não é conhecida de antemão, e o loop \n",
    "    deve continuar com base em uma condição.\n",
    "\n",
    "Exemplo:\n",
    "\n",
    "count = 0\n",
    "while count < 5:\n",
    "    print(count)\n",
    "    count += 1\n",
    "\n",
    "\n",
    "Loop for\n",
    "\n",
    "    Iteração sobre uma Sequência: O loop for é usado para iterar sobre uma \n",
    "    sequência (lista, tupla, dicionário, conjunto ou string), percorrendo cada \n",
    "    elemento da sequência.\n",
    "    \n",
    "    Incremento/Decremento Automático: O controle do loop é gerenciado automaticamente \n",
    "    pelo próprio loop for.\n",
    "    \n",
    "    Geralmente Usado Quando: Você sabe o número de iterações de antemão, ou você \n",
    "    está iterando sobre uma sequência.\n",
    "\n",
    "Exemplo:\n",
    "\n",
    "for i in range(5):\n",
    "    print(i)\n",
    "\n",
    "Em resumo, o loop while é geralmente usado quando você quer continuar o \n",
    "loop com base em uma condição, e você pode não saber quantas vezes o loop precisa ser \n",
    "executado. O loop for, por outro lado, é mais comum quando você sabe quantas vezes quer \n",
    "iterar ou quando está trabalhando diretamente com uma sequência de elementos.\n",
    "\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51b1ca4d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "77e6ee05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "#for - utilizando números\n",
    "\n",
    "for i in range(10, 0, -1):\n",
    "    \n",
    "    print(i)\n",
    "    \n",
    "\"\"\"\n",
    "Explicação:\n",
    "\n",
    "    Loop For com Range: A estrutura for é usada para criar um loop que iterará \n",
    "    sobre uma sequência de valores. A função range(10, 0, -1) gera uma sequência de \n",
    "    números inteiros começando em 10 e terminando antes de 0, decrementando 1 a cada passo.\n",
    "    \n",
    "        O primeiro argumento 10 é o valor inicial.\n",
    "        \n",
    "        O segundo argumento 0 é o valor final (exclusivo).\n",
    "        \n",
    "        O terceiro argumento -1 é o passo, ou seja, a quantidade pela qual o \n",
    "        valor é alterado a cada iteração (neste caso, decrementado em 1).\n",
    "\n",
    "    Corpo do Loop: Dentro do loop, há uma única instrução:\n",
    "    \n",
    "        Imprimir Número Atual: A função print(i) imprime o valor atual da variável de loop i.\n",
    "\n",
    "    Execução do Loop: O loop será executado para cada valor de i na sequência gerada por \n",
    "    range(10, 0, -1), o que significa que ele será executado 10 vezes, com i assumindo os \n",
    "    valores de 10 a 1, um de cada vez, em ordem decrescente.\n",
    "\n",
    "\n",
    "O código ilustra como usar um loop for com a função range para iterar sobre uma \n",
    "sequência de números inteiros em ordem decrescente, executando uma ação (neste caso, \n",
    "imprimir o número) para cada valor na sequência.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b7fd012",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f3f01128",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "#for - utilizando números\n",
    "\n",
    "#De 1 a 10 com um passo de 2.\n",
    "\n",
    "#Começa em 2, termina antes de 12, com um passo de 2\n",
    "for i in range(2, 12, 2):\n",
    "    \n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "779cedab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Número impar atual: 1\n",
      "Número impar atual: 3\n",
      "Número impar atual: 5\n",
      "Número impar atual: 7\n",
      "Número impar atual: 9\n",
      "\n",
      "A soma dos números impares de 1 a 10 é: 25\n"
     ]
    }
   ],
   "source": [
    "# Inicializando a variável para armazenar a soma\n",
    "soma = 0\n",
    "\n",
    "# Iterando de 1 a 10, de 2 em 2 (capturando apenas os números ímpares)\n",
    "for i in range(1, 11, 2):\n",
    "    \n",
    "    print(f\"Número ímpar atual: {i}\")\n",
    "    \n",
    "    #soma = soma + i\n",
    "    soma += i  # Adicionando o número ímpar atual à soma\n",
    "\n",
    "print(f\"\\nA soma dos números ímpares de 1 a 10 é: {soma}\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd4b4ee2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3ec19919",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplicando por 1, o resultado parcial é 1\n",
      "Multiplicando por 2, o resultado parcial é 2\n",
      "Multiplicando por 3, o resultado parcial é 6\n",
      "Multiplicando por 4, o resultado parcial é 24\n",
      "Multiplicando por 5, o resultado parcial é 120\n",
      "O resultado final da multiplicação de 1 a 5 é: 120\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Multiplicação de Números\n",
    "\n",
    "Objetivo: Escreva um programa que utilize um loop for para multiplicar os \n",
    "números de 1 a 5 e imprima o resultado de cada etapa e o resultado final.\n",
    "\n",
    "Etapas:\n",
    "\n",
    "    - Utilize um loop for para iterar pelos números de 1 a 5.\n",
    "    - Multiplique cada número pelo resultado anterior (começando por 1).\n",
    "    - Imprima o resultado de cada etapa.\n",
    "    - Imprima o resultado final da multiplicação de todos os números.\n",
    "\n",
    "Saída:\n",
    "\n",
    "Multiplicando por 1, o resultado parcial é 1\n",
    "Multiplicando por 2, o resultado parcial é 2\n",
    "Multiplicando por 3, o resultado parcial é 6\n",
    "Multiplicando por 4, o resultado parcial é 24\n",
    "Multiplicando por 5, o resultado parcial é 120\n",
    "\"\"\"\n",
    "\n",
    "# Inicializando a variável resultado com 1\n",
    "resultado = 1\n",
    "\n",
    "# Utilizando um loop for para iterar pelos números de 1 a 5\n",
    "for numero in range(1, 6):\n",
    "    \n",
    "    # Multiplicando o resultado pelo número atual\n",
    "    #resultado = resultado * numero\n",
    "    resultado *= numero \n",
    "    \n",
    "    print(f\"Multiplicando por {numero}, o resultado parcial é {resultado}\")\n",
    "\n",
    "print(f\"O resultado final da multiplicação de 1 a 5 é: {resultado}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "caec0cc2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "111db778",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número inteiro positivo: 6\n",
      "Número: 2 + 0 = 2\n",
      "Número: 4 + 2 = 6\n",
      "Número: 6 + 6 = 12\n",
      "A soma dos números pares de 1 até 6 é 12\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Soma de Números Pares\n",
    "\n",
    "Objetivo: Escreva um programa que peça ao usuário um número \n",
    "inteiro N e some todos os números pares de 1 até N, incluindo o próprio N (se for par). \n",
    "\n",
    "Utilize um loop for para esta tarefa.\n",
    "\n",
    "Etapas:\n",
    "\n",
    "    - Solicite ao usuário um número inteiro positivo N.\n",
    "    - Utilize um loop for para iterar de 1 a N e some todos os números pares.\n",
    "    - Imprima o resultado da soma.\n",
    "\n",
    "\n",
    "Exemplo de Saída:\n",
    "\n",
    "Digite um número inteiro positivo: 10\n",
    "A soma dos números pares de 1 até 10 é: 30\n",
    "\"\"\"\n",
    "\n",
    "# Solicitando ao usuário o número\n",
    "N = int(input(\"Digite um número inteiro positivo: \"))\n",
    "\n",
    "# Inicializando a variável para armazenar a soma\n",
    "soma_pares = 0\n",
    "\n",
    "# Utilizando um loop for para somar os números pares de 1 até N\n",
    "for i in range(1, N + 1):\n",
    "    \n",
    "    # Verificando se o número é par\n",
    "    if i % 2 == 0: \n",
    "        \n",
    "        #Imprime cada etapa\n",
    "        print(f\"Número: {i} + {soma_pares} = {i+soma_pares}\")\n",
    "        \n",
    "        soma_pares += i\n",
    "        \n",
    "        \n",
    "\n",
    "# Imprimindo o resultado\n",
    "print(f\"A soma dos números pares de 1 até {N} é: {soma_pares}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "266b5119",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c3defaa3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número inteiro positivo para exibir a sua tabela de multiplicação: 5\n",
      "5 x 1 = 5\n",
      "5 x 2 = 10\n",
      "5 x 3 = 15\n",
      "5 x 4 = 20\n",
      "5 x 5 = 25\n",
      "5 x 6 = 30\n",
      "5 x 7 = 35\n",
      "5 x 8 = 40\n",
      "5 x 9 = 45\n",
      "5 x 10 = 50\n",
      "Fim da tabela de multiplicação.\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Tabela de Multiplicação\n",
    "\n",
    "Objetivo: Escreva um programa que peça ao usuário um número inteiro positivo NN e \n",
    "exiba a tabela de multiplicação para esse número, de 1 a 10. Utilize um loop for para esta tarefa.\n",
    "\n",
    "Etapas:\n",
    "\n",
    "    - Solicite ao usuário um número inteiro positivo NN.\n",
    "    - Utilize um loop for para iterar de 1 a 10.\n",
    "    - Para cada iteração, multiplique o número NN pelo valor da iteração e imprima o resultado.\n",
    "    \n",
    "Exemplo de Saída:\n",
    "\n",
    "Digite um número inteiro positivo para exibir a sua tabela de multiplicação: 5\n",
    "\n",
    "5 x 1 = 5\n",
    "5 x 2 = 10\n",
    "5 x 3 = 15\n",
    "5 x 4 = 20\n",
    "5 x 5 = 25\n",
    "5 x 6 = 30\n",
    "5 x 7 = 35\n",
    "5 x 8 = 40\n",
    "5 x 9 = 45\n",
    "5 x 10 = 50\n",
    "Fim da tabela de multiplicação.\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "# Solicitando ao usuário o número para criar a tabela de multiplicação\n",
    "N = int(input(\"Digite um número inteiro positivo para exibir a sua tabela de multiplicação: \"))\n",
    "\n",
    "# Utilizando um loop for para criar a tabela de multiplicação de 1 a 10\n",
    "for i in range(1, 11):\n",
    "    \n",
    "    resultado = N * i # Calculando o resultado da multiplicação\n",
    "    \n",
    "    print(f\"{N} x {i} = {resultado}\") # Imprimindo o resultado\n",
    "\n",
    "# Imprimindo uma linha final\n",
    "print(\"Fim da tabela de multiplicação.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fa35e0f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "218914fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número inteiro positivo: 5\n",
      "Quadrado de 1: 1\n",
      "Quadrado de 2: 4\n",
      "Quadrado de 3: 9\n",
      "Quadrado de 4: 16\n",
      "Quadrado de 5: 25\n",
      "A soma dos quadrados dos números de 1 até 5 é: 55\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Soma dos Quadrados\n",
    "\n",
    "Objetivo: Escreva um programa que peça ao usuário um número inteiro positivo NN e \n",
    "calcule a soma dos quadrados de todos os números inteiros de 1 até NN. Utilize um loop \n",
    "for para esta tarefa.\n",
    "\n",
    "Etapas:\n",
    "\n",
    "    - Solicite ao usuário um número inteiro positivo NN.\n",
    "    \n",
    "    - Utilize um loop for para iterar de 1 a NN, calculando o quadrado \n",
    "    de cada número e somando-o a uma variável.\n",
    "    \n",
    "    - Imprima o resultado da soma.\n",
    "\n",
    "Exemplo de Saída:\n",
    "\n",
    "Digite um número inteiro positivo: 5\n",
    "Quadrado de 1: 1\n",
    "Quadrado de 2: 4\n",
    "Quadrado de 3: 9\n",
    "Quadrado de 4: 16\n",
    "Quadrado de 5: 25\n",
    "A soma dos quadrados dos números de 1 até 5 é: 55\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "# Solicitando ao usuário o número\n",
    "N = int(input(\"Digite um número inteiro positivo: \"))\n",
    "\n",
    "# Inicializando a variável para armazenar a soma dos quadrados\n",
    "soma_quadrados = 0\n",
    "\n",
    "# Utilizando um loop for para somar os quadrados de 1 até N\n",
    "for i in range(1, N + 1):\n",
    "    quadrado = i**2 # Calculando o quadrado do número\n",
    "    print(f\"Quadrado de {i}: {quadrado}\") # Imprimindo o quadrado do número\n",
    "    soma_quadrados += quadrado # Adicionando o quadrado à soma\n",
    "\n",
    "# Imprimindo o resultado\n",
    "print(f\"A soma dos quadrados dos números de 1 até {N} é: {soma_quadrados}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "abdcbfcb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "742d934e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "B\n",
      "C\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#For - Utilizando Strings\n",
    "#loop for para iterar sobre uma lista de caracteres alfabéticos, \n",
    "#imprimindo cada item da lista até encontrar o caractere \"C\"\n",
    "\n",
    "#For = Para\n",
    "\n",
    "lista = [\"A\", \"B\", \"C\", \"D\", \"E\"]\n",
    "\n",
    "for item in lista:\n",
    "    \n",
    "    print(item)\n",
    "    \n",
    "    if item == \"C\":\n",
    "        \n",
    "        break\n",
    "        \n",
    "\"\"\"\n",
    "Explicação:\n",
    "\n",
    "    Definindo a Lista: A variável lista é inicializada com uma lista de \n",
    "    caracteres alfabéticos [\"A\", \"B\", \"C\", \"D\", \"E\"].\n",
    "\n",
    "    Loop For: A estrutura for é usada para criar um loop que iterará sobre \n",
    "    cada elemento da lista lista.\n",
    "\n",
    "    Corpo do Loop: Dentro do loop, há duas instruções:\n",
    "    \n",
    "        Imprimir Item Atual: A função print(item) imprime o valor atual da \n",
    "        variável de loop item.\n",
    "        \n",
    "        Condição de Parada (if): A instrução if verifica se o valor atual \n",
    "        de item é igual a \"C\". Se essa condição for verdadeira, a instrução break \n",
    "        é executada, interrompendo o loop imediatamente.\n",
    "\n",
    "    Execução do Loop: Veja como ele se comporta em cada iteração:\n",
    "    \n",
    "        Iteração 1: item é \"A\", é impresso, e o loop continua.\n",
    "        \n",
    "        Iteração 2: item é \"B\", é impresso, e o loop continua.\n",
    "        \n",
    "        Iteração 3: item é \"C\", é impresso, e então a condição item == \"C\" é \n",
    "        verdadeira, o que aciona a instrução break.\n",
    "        \n",
    "        O loop é interrompido, e o programa termina sua execução.\n",
    "\n",
    "O código demonstra como usar um loop for juntamente com uma instrução condicional \n",
    "if e a palavra-chave break para controlar a execução do loop. Neste exemplo, o loop é interrompido \n",
    "quando o item \"C\" é encontrado na lista.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ff0785e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "3a138795",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maça\n",
      "banana\n",
      "laranja\n"
     ]
    }
   ],
   "source": [
    "#For - Utilizando Strings\n",
    "\n",
    "#For = Para\n",
    "\n",
    "# Iterando sobre uma lista\n",
    "frutas = [\"maçã\", \"banana\", \"laranja\"]\n",
    "\n",
    "for fruta in frutas:\n",
    "    \n",
    "    print(fruta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9823dc61",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "a50271f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número: 5\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "numero = int(input(\"Digite um número: \"))\n",
    "\n",
    "for i in range(1, numero + 1):\n",
    "    \n",
    "    print(i)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ef9979d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "fd40a7b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 é ímpar\n",
      "2 é par\n",
      "3 é ímpar\n",
      "4 é par\n",
      "5 é ímpar\n",
      "6 é par\n",
      "7 é ímpar\n",
      "8 é par\n",
      "9 é ímpar\n",
      "10 é par\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#For Utilizando If e Else\n",
    "#Verifica se é par ou ímpar e imprime uma mensagem correspondente. \n",
    "    \n",
    "# Iterando sobre uma lista de números e aplicando uma condição\n",
    "numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "# Inicia um loop 'for' para iterar através de cada número na lista 'numeros'\n",
    "for numero in numeros:\n",
    "    \n",
    "    # Verifica se o número atual é par usando o operador de módulo (%), que retorna o resto da divisão por 2\n",
    "    if numero % 2 == 0:\n",
    "        \n",
    "        # Se o número for par, imprime a mensagem indicando que o número é par\n",
    "        print(numero, \"é par\")\n",
    "        \n",
    "    else:\n",
    "        \n",
    "        # Se o número não for par (ou seja, ímpar), imprime a mensagem indicando que o número é ímpar\n",
    "        print(numero, \"é ímpar\")\n",
    "\n",
    "        \n",
    "        \n",
    "\"\"\"\n",
    "Explicação:\n",
    "\n",
    "    Definindo a Lista: A variável numeros é inicializada com uma \n",
    "    lista de números inteiros de 1 a 10.\n",
    "\n",
    "    Loop For: A estrutura for é usada para criar um loop que iterará \n",
    "    sobre cada elemento da lista numeros.\n",
    "\n",
    "    Corpo do Loop: Dentro do loop, há uma estrutura condicional if-else:\n",
    "    \n",
    "        Verificar se é Par: A instrução if numero % 2 == 0 verifica \n",
    "        se o valor atual de numero é par (ou seja, divisível por 2 sem resto). \n",
    "        \n",
    "        Se for verdade, o programa imprime \"<numero> é par\".\n",
    "        \n",
    "        Caso Contrário, é Ímpar: Se a condição acima não for verdadeira, \n",
    "        o programa entra na cláusula else e imprime \"<numero> é ímpar\".\n",
    "\n",
    "    Execução do Loop: O loop será executado para cada valor de numero na \n",
    "    lista numeros, verificando se cada número é par ou ímpar e imprimindo \n",
    "    a mensagem correspondente.\n",
    "\n",
    "\n",
    "O código ilustra como usar um loop for juntamente com uma instrução \n",
    "condicional if-else para iterar sobre uma lista de números, executando uma \n",
    "verificação e imprimindo uma mensagem correspondente para cada número na lista.\n",
    "\"\"\"\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56cf6e3b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "cee88fc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eu preciso comprar maçã\n",
      "Eu preciso comprar banana\n",
      "Eu preciso comprar cenoura\n",
      "Eu preciso comprar leite\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Lista de Compras\n",
    "\n",
    "Objetivo: Use um loop for para iterar sobre uma lista de itens de \n",
    "compras e imprimir cada item em um formato específico.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Crie uma lista chamada itens_compra contendo alguns itens que \n",
    "    você compraria em uma loja, por exemplo: [\"maçã\", \"banana\", \"cenoura\", \"leite\"].\n",
    "    \n",
    "    2. Use um loop for para iterar sobre os itens da lista.\n",
    "    3. Para cada item na lista, imprima o item no seguinte formato: \"Eu preciso comprar [item]\".\n",
    "\n",
    "Após concluir o exercício, sua saída deve se parecer com:\n",
    "\n",
    "Eu preciso comprar maçã\n",
    "Eu preciso comprar banana\n",
    "Eu preciso comprar cenoura\n",
    "Eu preciso comprar leite\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "# Criando uma lista chamada 'itens_compra' contendo quatro itens (strings).\n",
    "itens_compra = [\"maçã\", \"banana\", \"cenoura\", \"leite\"]\n",
    "\n",
    "# Iniciando um loop 'for' que irá iterar sobre cada 'item' na lista 'itens_compra'.\n",
    "for item in itens_compra:\n",
    "    \n",
    "    # Imprimindo uma frase com o item atual da iteração.\n",
    "    # A função 'print' automaticamente insere um espaço entre os argumentos.\n",
    "    print(\"Eu preciso comprar\", item)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c123604",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "86ae9ef7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*****\n",
      "****\n",
      "***\n",
      "**\n",
      "*\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Estrelas Descendentes\n",
    "\n",
    "Objetivo: Use um loop for para criar um padrão descendente \n",
    "de estrelas (*). Comece com 5 estrelas na primeira linha e reduza \n",
    "uma estrela em cada linha subsequente até não restar nenhuma estrela.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Use um loop for para iterar de 5 a 0 (dica: pense sobre \n",
    "    a função range() de maneira descendente).\n",
    "    \n",
    "    2. Em cada iteração do loop, imprima o número atual \n",
    "    de estrelas em uma única linha.\n",
    "\n",
    "Após concluir o exercício, sua saída deve se parecer com:\n",
    "\n",
    "*****\n",
    "****\n",
    "***\n",
    "**\n",
    "*\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "# Itera sobre os números de 5 a 1 (inclusive) em ordem descendente\n",
    "for i in range(5, 0, -1):\n",
    "    \n",
    "    # Imprime 'i' estrelas\n",
    "    print('*' * i)\n",
    "    \n",
    "\"\"\"\n",
    "Em Python, quando multiplicamos uma string por um número inteiro, obtemos \n",
    "a repetição dessa string pelo número especificado de vezes.\n",
    "\n",
    "Por exemplo:\n",
    "\n",
    "    'a' * 3 resultará em 'aaa'\n",
    "    'hello ' * 2 resultará em 'hello hello '\n",
    "\n",
    "No contexto do exercício, estamos usando essa característica \n",
    "para repetir o caractere de estrela (*) um determinado número de vezes (i).\n",
    "\n",
    "Vamos observar passo a passo como a expressão é avaliada durante cada iteração do loop:\n",
    "\n",
    "    Quando i é 5: print('*' * 5) → Imprime *****\n",
    "    Quando i é 4: print('*' * 4) → Imprime ****\n",
    "    Quando i é 3: print('*' * 3) → Imprime ***\n",
    "    Quando i é 2: print('*' * 2) → Imprime **\n",
    "    Quando i é 1: print('*' * 1) → Imprime *\n",
    "\n",
    "Desta forma, obtemos o padrão descendente de estrelas desejado. O \n",
    "loop for controla o número de vezes que o caractere de estrela é repetido, e a \n",
    "multiplicação da string cuida da repetição do caractere em si.\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f6d4e06",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "b10e1249",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "carro\n",
      "árvore\n",
      "professor\n",
      "aluno\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício: Palavras com Mais de 4 Letras\n",
    "\n",
    "Objetivo: Solicite ao usuário uma lista de palavras e, em \n",
    "seguida, exiba apenas as palavras que têm mais de 4 letras.\n",
    "\n",
    "Instruções:\n",
    "\n",
    "    1. Peça ao usuário que insira palavras separadas \n",
    "    por vírgula (por exemplo, [\"casa\",\"carro\",\"sol\",\"árvore\"]).\n",
    "    \n",
    "    2. Use um loop for para iterar sobre essa lista de palavras.\n",
    "    \n",
    "    3. Dentro do loop, verifique o comprimento de cada palavra.\n",
    "    \n",
    "    4. Se a palavra tiver mais de 4 letras, imprima-a.\n",
    "\n",
    "Após concluir o exercício, se o usuário inserir \"casa,carro,sol,árvore\", a saída deve ser:\n",
    "\n",
    "carro\n",
    "árvore\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "# lista de palavras\n",
    "palavras = [\"casa\",\"carro\",\"sol\",\"árvore\", \"ovo\", \"professor\", \"aluno\"]\n",
    "\n",
    "# Itera sobre a lista de palavras\n",
    "for palavra in palavras:\n",
    "    \n",
    "    # Verifica se a palavra tem mais de 4 letras\n",
    "    if len(palavra) > 4:\n",
    "        \n",
    "        # Imprime a palavra\n",
    "        print(palavra)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75d0f899",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6f84ca03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 * 1 = 1\n",
      "1 * 2 = 2\n",
      "1 * 3 = 3\n",
      "2 * 1 = 2\n",
      "2 * 2 = 4\n",
      "2 * 3 = 6\n",
      "3 * 1 = 3\n",
      "3 * 2 = 6\n",
      "3 * 3 = 9\n"
     ]
    }
   ],
   "source": [
    "#For Nested loops\n",
    "\n",
    "\"\"\"\n",
    "For Nested Loops\" refere-se à prática de aninhar um ou mais \n",
    "loops for dentro de outro loop for. Em outras palavras, é quando \n",
    "você tem um loop for dentro do corpo de outro loop for. Esse conceito é \n",
    "aplicável em várias linguagens de programação, incluindo Python.\n",
    "\"\"\"\n",
    "\n",
    "# Exemplo de loops aninhados\n",
    "# Inicia o loop externo, iterando a variável 'i' de 1 a 3 (o valor final 4 é exclusivo)\n",
    "for linha in range(1, 4):\n",
    "    \n",
    "    # Inicia o loop interno, iterando a variável 'j' de 1 a 3 (o valor final 4 \n",
    "    #é exclusivo) para cada valor de 'i'\n",
    "    for coluna in range(1, 4):\n",
    "        \n",
    "        # Imprime o produto de 'i' e 'j', junto com os valores de 'i' e 'j' e os \n",
    "        #símbolos de multiplicação e igual\n",
    "        print(i, \"*\", j, \"=\", i * j)\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Explicação:\n",
    "\n",
    "    Loop Externo For: O loop externo for i in range(1, 4) iterará sobre a \n",
    "    sequência de números inteiros de 1 a 3 (inclusive). A variável de loop i \n",
    "    assumirá esses valores, um de cada vez.\n",
    "\n",
    "    Loop Interno For: Dentro do loop externo, há outro loop for, denotado por \n",
    "    for j in range(1, 4). Este loop interno iterará sobre a mesma sequência de \n",
    "    números inteiros de 1 a 3 (inclusive). A variável de loop j assumirá esses \n",
    "    valores, um de cada vez.\n",
    "\n",
    "    Corpo do Loop Interno: Dentro do loop interno, há uma única instrução:\n",
    "    \n",
    "        Imprimir Multiplicação: A função print(i, \"*\", j, \"=\", i * j) imprime a expressão \n",
    "        de multiplicação atual e seu resultado. Por exemplo, se i é 2 e j é 3, ele \n",
    "        imprimirá 2 * 3 = 6.\n",
    "\n",
    "    Execução dos Loops Aninhados: O loop interno será executado completamente para \n",
    "    cada valor de i do loop externo. Como ambos os loops variam de 1 a 3, haverá um \n",
    "    total de 3×3=93×3=9 iterações para o loop interno.\n",
    "\n",
    "\n",
    "O código ilustra o conceito de loops aninhados em Python, onde um loop \n",
    "é colocado dentro de outro loop. Neste exemplo, os loops aninhados são usados \n",
    "para gerar uma pequena tabela de multiplicação, demonstrando a relação de \n",
    "multiplicação entre os números de 1 a 3.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cea3febe",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "934f2433",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 25, 49, 81]\n",
      "\n",
      "[1, 9, 25, 49, 81]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "compreensão de lista (list comprehension) em Python, que é uma maneira \n",
    "concisa de criar listas. Aqui está um exemplo que combina um for e um if em \n",
    "uma única linha para criar uma lista de quadrados dos números ímpares de 0 a 9:\n",
    "\"\"\"\n",
    "\n",
    "quadrados_impares = [x**2 for x in range(10) if x % 2 != 0]\n",
    "print(quadrados_impares)\n",
    "\n",
    "\"\"\"\n",
    "Ao executar este código, a lista quadrados_impares conterá os \n",
    "valores [1, 9, 25, 49, 81], que são os quadrados dos números \n",
    "ímpares entre 0 e 9.\n",
    "\n",
    "Explicando o código:\n",
    "\n",
    "    Vamos destrinchar a compreensão de lista [x**2 for x in range(10) if x % 2 != 0]:\n",
    "\n",
    "    for x in range(10): Esta é a parte principal do loop. Ela vai \n",
    "    iterar sobre os números de 0 a 9 (isso é o que range(10) faz).\n",
    "\n",
    "    if x % 2 != 0: Esta é a condição de filtragem. A expressão x % 2 retorna \n",
    "    o resto da divisão de x por 2. Se x for ímpar, esse resto será diferente \n",
    "    de 0. Portanto, esta condição verifica se x é ímpar.\n",
    "\n",
    "    x**2: Esta é a expressão que será avaliada para cada x que satisfaça a \n",
    "    condição acima. Ou seja, para cada número ímpar x no intervalo de 0 a 9, esta \n",
    "    expressão calculará seu quadrado.\n",
    "    \n",
    "\n",
    "Agora, vamos converter essa compreensão de lista em um loop for tradicional:\n",
    "\n",
    "\n",
    "quadrados_impares = []  # Lista vazia para armazenar os quadrados dos números ímpares\n",
    "\n",
    "for x in range(10):  # Itera sobre os números de 0 a 9\n",
    "    if x % 2 != 0:  # Verifica se x é ímpar\n",
    "        quadrados_impares.append(x**2)  # Calcula o quadrado de x e adiciona à lista\n",
    "\n",
    "print(quadrados_impares)\n",
    "\n",
    "\n",
    "No final deste loop, a lista quadrados_impares terá os mesmos valores que a \n",
    "compreensão de lista original produziria: [1, 9, 25, 49, 81].\n",
    "\"\"\"\n",
    "\n",
    "print()\n",
    "\n",
    "quadrados_impares = []\n",
    "\n",
    "for x in range(10):  # Itera sobre os números de 0 a 9\n",
    "    if x % 2 != 0:  # Verifica se x é ímpar\n",
    "        quadrados_impares.append(x**2)  # Calcula o quadrado de x e adiciona à lista\n",
    "\n",
    "print(quadrados_impares)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68d76930",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0a0876dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['H', 'l', 'l', ' ', 'W', 'r', 'l', 'd']\n",
      "['H', 'l', 'l', ' ', 'W', 'r', 'l', 'd']\n"
     ]
    }
   ],
   "source": [
    "#List Comprehensions (Compreensão de Listas)\n",
    "#Criando uma lista de todos os caracteres em uma string que não são vogais:\n",
    "texto = \"Hello World\"\n",
    "consoantes = [char for char in texto if char.lower() not in 'aeiou']\n",
    "print(consoantes)\n",
    "\n",
    "\"\"\"\n",
    "Vamos destrinchar a compreensão de lista: [char for char in texto if char.lower() not in 'aeiou'].\n",
    "\n",
    "    for char in texto: Este é o loop principal que itera sobre cada \n",
    "    caractere da string texto.\n",
    "\n",
    "    char.lower(): Esta é uma conversão do caractere atual para minúsculas. Isso \n",
    "    garante que a comparação funcione tanto para letras maiúsculas quanto minúsculas.\n",
    "\n",
    "    if char.lower() not in 'aeiou': Esta é a condição de filtragem. Ela verifica \n",
    "    se o caractere (convertido para minúsculo) não está na string 'aeiou', que contém \n",
    "    todas as vogais minúsculas. Assim, a condição se torna verdadeira apenas para \n",
    "    consoantes (e outros caracteres que não são vogais, como espaços, pontuação, etc.)\n",
    "\n",
    "    char: Esta é a expressão a ser avaliada e adicionada à lista resultante para \n",
    "    cada char que satisfaça a condição acima. No contexto desta compreensão de lista, apenas \n",
    "    retorna o próprio caractere.\n",
    "\n",
    "Vamos converter essa compreensão de lista para um loop for tradicional:\n",
    "\"\"\"\n",
    "\n",
    "#consoantes = [char for char in texto if char.lower() not in 'aeiou']\n",
    "\n",
    "consoantes = []\n",
    "\n",
    "\n",
    "# Lista vazia para armazenar os caracteres que não são vogais\n",
    "consoantes_exemplo2 = []  \n",
    "\n",
    "# Itera sobre cada caractere na string 'texto'\n",
    "for letra in texto:  \n",
    "    \n",
    "    # Verifica se o caractere não é uma vogal\n",
    "    if letra.lower() not in 'aeiou':  \n",
    "        \n",
    "        # Adiciona o caractere à lista 'consoantes'\n",
    "        consoantes_exemplo2.append(letra)\n",
    "        \n",
    "print(consoantes_exemplo2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cea91d6e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "dfa57791",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número inteiro não negativo: 5\n",
      "O fatorial de 5 é: 120\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício\n",
    "\n",
    "Crie um programa em Python que solicite ao usuário que digite um número inteiro\n",
    "não negativo. Em seguida, calcule e exiba o fatorial desse número.\n",
    "\n",
    "Digite um número inteiro não negativo: 5\n",
    "O fatorial de 5 é: 120\n",
    "\"\"\"\n",
    "\n",
    "# Solicita ao usuário a entrada de um número inteiro não negativo\n",
    "numero = int(input(\"Digite um número inteiro não negativo: \"))\n",
    "\n",
    "# Verifica se o número informado é negativo\n",
    "if numero < 0:\n",
    "    \n",
    "    # Se for negativo, exibe uma mensagem de erro\n",
    "    print(\"O número deve ser não negativo.\")\n",
    "    \n",
    "else:\n",
    "    \n",
    "    # Inicializa uma variável para armazenar o fatorial do número\n",
    "    fatorial = 1\n",
    "\n",
    "    # Loop que percorre todos os números inteiros de 1 até o número informado pelo usuário (inclusive)\n",
    "    for i in range(1, numero + 1):\n",
    "        \n",
    "        # Multiplica o valor atual de 'fatorial' pelo número atual (i) na iteração\n",
    "        # fatorial = fatorial * i\n",
    "        fatorial *= i\n",
    "\n",
    "    # Imprime o resultado final, que é o fatorial do número informado pelo usuário\n",
    "    print(\"O fatorial de\", numero, \"é:\", fatorial)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "713c8941",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "cf13eebd",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número inteiro não negativo: 5\n",
      "Cálculo do fatorial de 5 :\n",
      "1! = 1 =  1\n",
      "2! = 1 * 2 =  2\n",
      "3! = 1 * 2 * 3 =  6\n",
      "4! = 1 * 2 * 3 * 4 =  24\n",
      "5! = 1 * 2 * 3 * 4 * 5 =  120\n",
      "O fatorial de 5 é: 120\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Exercício\n",
    "\n",
    "Crie um programa em Python que solicite ao usuário que digite um número inteiro\n",
    "não negativo. Em seguida, calcule e exiba o fatorial desse número.\n",
    "\n",
    "Digite um número inteiro não negativo: 5\n",
    "O fatorial de 5 é: 120\n",
    "\"\"\"\n",
    "\n",
    "# Solicita ao usuário a entrada de um número inteiro não negativo\n",
    "numero = int(input(\"Digite um número inteiro não negativo: \"))\n",
    "\n",
    "# Verifica se o número informado é negativo\n",
    "if numero < 0:\n",
    "    \n",
    "    # Se for negativo, exibe uma mensagem de erro\n",
    "    print(\"O número deve ser não negativo.\")\n",
    "    \n",
    "else:\n",
    "    \n",
    "    # Inicializa uma variável para armazenar o fatorial do número\n",
    "    fatorial = 1\n",
    "    \n",
    "    # Imprime a mensagem inicial indicando o cálculo do fatorial\n",
    "    print(\"Cálculo do fatorial de\", numero, \":\")\n",
    "\n",
    "    # Loop para multiplicar os números de 1 até o número informado\n",
    "    for multiplicador in range(1, numero + 1):\n",
    "        \n",
    "        # Multiplica o valor atual de 'fatorial' pelo número atual na iteração\n",
    "        fatorial *= multiplicador\n",
    "        \n",
    "        # Imprime o número da iteração atual seguido de \"!\" e o símbolo de igual\n",
    "        print(f\"{multiplicador}! =\", end=\" \")\n",
    "\n",
    "        # Loop para imprimir a expressão do fatorial (e.g., \"1 * 2 * 3\")\n",
    "        for i in range(1, multiplicador + 1):\n",
    "            \n",
    "            print(i, end=\"\")\n",
    "            \n",
    "            if i != multiplicador:\n",
    "                \n",
    "                # Imprime o símbolo de multiplicação se não for o último número\n",
    "                print(\" * \", end=\"\")\n",
    "                \n",
    "        # Imprime o resultado parcial do fatorial para a iteração atual\n",
    "        print(\" = \", fatorial)\n",
    "\n",
    "    # Imprime o resultado final, que é o fatorial do número informado pelo usuário\n",
    "    print(\"O fatorial de\", numero, \"é:\", fatorial)\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "numero = int(input(\"Digite um número inteiro não negativo: \")): O código inicia \n",
    "solicitando ao usuário que insira um número inteiro não negativo. A função input é \n",
    "usada para receber a entrada do usuário como uma string, e int() é usada para converter \n",
    "essa string em um número inteiro.\n",
    "\n",
    "if numero < 0:: Aqui é realizada uma verificação para garantir que o número inserido pelo \n",
    "usuário não seja negativo. Se o número for negativo, o código entra no bloco do if.\n",
    "\n",
    "print(\"O número deve ser não negativo.\"): Caso o número seja negativo, uma mensagem de erro é \n",
    "exibida, informando ao usuário que o número deve ser não negativo.\n",
    "\n",
    "else:: Se o número inserido pelo usuário for não negativo, o código entra no bloco do else.\n",
    "\n",
    "fatorial = 1: É inicializada uma variável chamada fatorial com o valor 1. Essa variável será \n",
    "usada para armazenar o resultado do fatorial do número informado pelo usuário.\n",
    "\n",
    "print(\"Cálculo do fatorial de\", numero, \":\"): Uma mensagem é impressa indicando o início do \n",
    "cálculo do fatorial do número informado.\n",
    "\n",
    "for multiplicador in range(1, numero + 1):: Aqui, é utilizado um loop for para iterar de 1 até o \n",
    "valor do número informado pelo usuário (incluindo o próprio número).\n",
    "\n",
    "fatorial *= multiplicador: Em cada iteração do loop, o valor atual da variável fatorial é \n",
    "multiplicado pelo número atual na iteração. Isso é feito para calcular o fatorial.\n",
    "\n",
    "print(f\"{multiplicador}! =\", end=\" \"): A cada iteração do loop, uma mensagem é impressa mostrando \n",
    "o número da iteração seguido do símbolo \"!\" e o símbolo de igual.\n",
    "\n",
    "for i in range(1, multiplicador + 1):: É utilizado outro loop for dentro do loop principal para \n",
    "criar a expressão do fatorial (por exemplo, \"1 * 2 * 3\") que será impressa na saída.\n",
    "\n",
    "print(i, end=\"\"): O valor atual de i é impresso sem quebra de linha (end=\"\"), para que os \n",
    "números sejam impressos sequencialmente.\n",
    "\n",
    "if i != multiplicador:: É feita uma verificação para saber se o valor de i é diferente do \n",
    "valor atual do multiplicador na iteração. Se for diferente, significa que não estamos na \n",
    "última iteração do loop, então o símbolo de multiplicação \"*\" é impresso.\n",
    "\n",
    "print(\" * \", end=\"\"): O símbolo de multiplicação \"*\" é impresso na mesma linha, sem quebra de linha.\n",
    "\n",
    "print(\" = \", fatorial): Após o loop interno ser concluído, é impresso o símbolo de igual \"=\" seguido \n",
    "do valor atual do fatorial até a iteração atual.\n",
    "\n",
    "print(\"O fatorial de\", numero, \"é:\", fatorial): Após o loop principal ser concluído, é impresso o \n",
    "resultado final, que é o fatorial do número informado pelo usuário.\n",
    "\n",
    "O código utiliza loops para calcular o fatorial e imprimir a expressão do cálculo passo a passo. \n",
    "\n",
    "Ao final, o resultado é apresentado ao usuário. O fatorial de um número é o produto de todos os \n",
    "inteiros positivos menores ou iguais a ele. Por exemplo, o fatorial de 5 é 5! = 5 * 4 * 3 * 2 * 1 = 120.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3012ac9c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "8959facd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* * * * * \n",
      "* * * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "#For Criando um Retangulo\n",
    "\n",
    "# Criando um retângulo com loops for\n",
    "largura = 5  # Define a largura do retângulo\n",
    "altura = 3   # Define a altura do retângulo\n",
    "\n",
    "for i in range(altura):  # Loop para iterar pelas linhas do retângulo\n",
    "    \n",
    "    for j in range(largura):  # Loop para iterar pelas colunas do retângulo\n",
    "    \n",
    "        print(\"*\", end=\" \")  # Imprime o caractere \"*\" e um espaço na mesma linha\n",
    "    \n",
    "    print()  # Avança para a próxima linha após imprimir uma linha completa\n",
    "\n",
    "\"\"\"\n",
    "O código usa dois loops for aninhados para criar e imprimir\n",
    "um retângulo feito de caracteres asteriscos (*). A largura e a altura do\n",
    "retângulo são definidas pelas variáveis largura e altura.\n",
    "\n",
    "Explicação:\n",
    "\n",
    "    Definindo Largura e Altura: As variáveis largura e altura são\n",
    "    definidas como 5 e 3, respectivamente. Elas determinam as\n",
    "    dimensões do retângulo.\n",
    "\n",
    "    Loop Externo For: O loop externo for i in range(altura) itera altura\n",
    "    vezes, controlando o número de linhas do retângulo.\n",
    "\n",
    "    Loop Interno For: Dentro do loop externo, há um loop interno for j\n",
    "    in range(largura), que itera largura vezes, controlando o\n",
    "    número de colunas do retângulo.\n",
    "\n",
    "    Imprimir Caractere e Espaço: Dentro do loop interno, a função \n",
    "    print(\"*\", end=\" \") imprime o caractere asterisco (*) seguido de um\n",
    "    espaço. O argumento end=\" \" garante que o próximo caractere seja impresso na\n",
    "    mesma linha, em vez de avançar para a próxima linha.\n",
    "\n",
    "    Avançar para a Próxima Linha: Após imprimir uma linha completa (loop interno),\n",
    "    a função print() sem argumentos é chamada. Isso serve para avançar para a próxima\n",
    "    linha, permitindo que o próximo conjunto de asteriscos seja impresso em uma nova linha.\n",
    "\n",
    "    Execução dos Loops Aninhados: O loop interno será executado completamente para\n",
    "    cada iteração do loop externo, criando o padrão retangular desejado.\n",
    "\n",
    "Saída:\n",
    "\n",
    "A saída do programa será um retângulo de asteriscos com 5 colunas e 3 linhas:\n",
    "\n",
    "* * * * * \n",
    "* * * * * \n",
    "* * * * * \n",
    "\n",
    "O código ilustra o conceito de loops aninhados em Python e como eles podem\n",
    "ser usados para criar padrões e formas geométricas. É um exemplo comum de manipulação\n",
    "de loops para produzir saídas visuais.\n",
    "\"\"\"\n",
    "print()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2445520c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f9a83e97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    *\n",
      "   ***\n",
      "  *****\n",
      " *******\n",
      "*********\n"
     ]
    }
   ],
   "source": [
    "# Criando um triângulo com a ponta no meios usando loops for\n",
    "\n",
    "altura  = 5\n",
    "\n",
    "for i in range(altura):\n",
    "    \n",
    "    \"\"\"\n",
    "    altura: É o valor definido anteriormente, representando a altura do triângulo.\n",
    "\n",
    "    i: É o contador do loop for, que varia de 0 até o valor de \n",
    "    altura - 1. Ou seja, i representa o número da linha atual \n",
    "    sendo construída do triângulo.\n",
    "\n",
    "    espacos: É a variável que irá armazenar a quantidade de espaços que serão \n",
    "    inseridos no início de cada linha do triângulo.\n",
    "\n",
    "    Agora, vamos entender a fórmula altura - i - 1:\n",
    "\n",
    "    O valor de i começa em 0 e aumenta em cada iteração até altura - 1. Isso \n",
    "    significa que na primeira iteração (i = 0), estamos construindo a linha de \n",
    "    número 1 do triângulo, na segunda iteração (i = 1), a linha de número 2, e \n",
    "    assim por diante.\n",
    "\n",
    "    Para cada linha sendo construída, queremos adicionar espaços no início \n",
    "    para criar o efeito de triangulação. A quantidade de espaços em cada linha \n",
    "    depende da posição da linha em relação ao topo do triângulo. Ou seja, quanto mais \n",
    "    perto do topo, mais espaços precisamos adicionar.\n",
    "\n",
    "    Para entender como a fórmula altura - i - 1 funciona, vamos considerar \n",
    "    o exemplo com altura = 5:\n",
    "\n",
    "    Para a primeira linha (i = 0), temos: espacos = 5 - 0 - 1 = 4. Isso significa \n",
    "    que devemos adicionar 4 espaços antes do primeiro asterisco na primeira linha.\n",
    "\n",
    "    Para a segunda linha (i = 1), temos: espacos = 5 - 1 - 1 = 3. Nesse caso, adicionamos \n",
    "    3 espaços antes do primeiro asterisco na segunda linha.\n",
    "\n",
    "    Para a terceira linha (i = 2), temos: espacos = 5 - 2 - 1 = 2. Adicionamos \n",
    "    2 espaços antes do primeiro asterisco na terceira linha.\n",
    "\n",
    "    E assim por diante...\n",
    "\n",
    "    À medida que o valor de i aumenta, a quantidade de espaços diminui, pois \n",
    "    estamos construindo linhas mais próximas da base do triângulo.\n",
    "    \n",
    "    \"\"\"\n",
    "    espacos = altura - i - 1\n",
    "    \n",
    "    \"\"\"\n",
    "    altura = 5: Aqui, uma variável chamada altura é definida com o \n",
    "    valor 5. Essa variável representa a altura do triângulo que \n",
    "    será impresso na saída.\n",
    "\n",
    "    for i in range(altura):: Este é um loop for que irá iterar \n",
    "    de 0 até o valor de altura - 1. Ou seja, no caso da altura ser 5, o \n",
    "    loop irá executar para i = 0, i = 1, i = 2, i = 3 e i = 4.\n",
    "\n",
    "    espacos = altura - i - 1: Aqui, é calculada a quantidade de espaços \n",
    "    que devem ser inseridos no início de cada linha do triângulo. A quantidade \n",
    "    de espaços diminui à medida que aumenta o valor de i, ou seja, à medida \n",
    "    que o loop avança.\n",
    "\n",
    "    asteriscos = 2 * i + 1: Essa linha é responsável por calcular a \n",
    "    quantidade de asteriscos que devem ser inseridos em cada linha do \n",
    "    triângulo. O valor de i é usado para calcular o número de asteriscos, \n",
    "    seguindo uma sequência de números ímpares. Quando i é 0, asteriscos \n",
    "    é igual a 1, quando i é 1, asteriscos é igual a 3, quando i é 2, \n",
    "    asteriscos é igual a 5 e assim por diante.\n",
    "\n",
    "    print(\" \" * espacos + \"*\" * asteriscos): Aqui, a linha do triângulo \n",
    "    é construída combinando os espaços calculados na variável espacos e os \n",
    "    asteriscos calculados na variável asteriscos. Essa linha é impressa na \n",
    "    saída do console.\n",
    "    \"\"\"\n",
    "    asteriscos = 2 * i + 1\n",
    "    print(\" \" * espacos + \"*\" * asteriscos)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c15123a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecf3dbbe",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90cbb72a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c8acae3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb9179d8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e1e4622",
   "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
}