educacao/decoda
11
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

desenvolvimento pre-lancamento

Browse Source 
Commit inicial - add do repo privado para o repo NT

style: changes header's logo and colors

style: changes home page first session layout

feat: creates about us home page section

chore: creates home page section for whom

chore: creates student materails home page section

chore: creates teachers materials home page section

chore: creates teacher materials home page section

style: changes primary color

style: changes color at activities page

style: changes about page color

style: changes name to Decoda

fix: changes route to about page at footer

fix: changes background color

style: changes game page header colors

style: changes footer colors

chore: adds home page sections title

style: changes main font family to Lato

style: adds title font

fix: changes sizes to be more responsive for mobile

ajuste no build vercel

atualiza regras envio homol

Adiciona instrucoes de uso

add JupyterLite

fix solucao turtle

Add Mole Mash e Modal de Falhas

Add Progress Bar na pagina de Atividades

fix game name

chore: atualiza lockfile removendo vercel analytics

inclusão de efeito ao mudar de fase

add mecanismo de solução de fases em debug

vite config test

add BaseGame e refator do MoleMash

refatoração turtle

refatoração automato

refatoração automato

add tag

bug 1 e 2 automato

mostrar apenas games em homologação na pagina de atividades

aumentar timeout das fases finais do Turtle

fix bug scroll

add video

refactor semaforo

arrumar ordem das cores

add build docs

update vercel

update vercel

update vercel

update vercel

update vercel

add vercel jupyter

add vercel jupyter

fix deploy Vercel

fix deploy Vercel

fix deploy Vercel

add cripto

add cripto

refatoração

fix tour Mole Mash

.

remover arquivos de controle

chore: adds development tag for activity card

remover arquivos de status indevidamente versionados

atualizar cores nas atividades

add Quebra Cabeças

add Quebra Cabeças

add iniciativas

add Iniciativas

alteração de fotos pesadas

fix menu mobile

fix menu mobile

fix menu mobile

add Aspirador

update icons

update identidade visual documentação

update jupyter

add kernel python local

add kernel python local

add kernel python local

feat: add health check

feat: add primeiros passos

add letramento

mover letramento de lugar

update path games

update path games

fix: ajuste clique rapido no botão executar

remover dead code

fix: refactor: extract shared utilities for storage, phase unlock and mobile detection

stabilize context references and fix stale closure

extrair GameProgressContext do GameStateContext (SRP)

refactor(game): extrair usePhaser e useGameModals de GameBase + corrigir bugs descobertos

refactor(game): remove todos os aliases PT/EN duplicados

Remover aliases PT/EN da camada de modais

refactor + tests

security: add CodeSanitizer and integrate into GameInterpreter

- CodeSanitizer.js: 4 built-in rules (max_length, infinite_while,
  infinite_for, excessive_nesting) with pluggable extra rules
- GameInterpreter.executeCode: calls sanitizeCode() before js-interpreter,
  differentiates CodeSanitizationError (warn) from other errors (error)
- 21 unit tests for CodeSanitizer (100% coverage)
- 4 integration tests in GameInterpreter for sanitization paths

add CodeSanitizer

fix: fase 10 aspirador

fix: bug semaforo

teste

feat: add version

Ajusta a landing page para ficar mais próxima ao protótipo

ajusta raio da borda do botão de Acesse nosso Laboratório

pequenos ajustes de layout na página de iniciativas

atualiza tabela de jogos educativos com os jogos disponíveis atualmente

ajustados pequenos detalhes e informações do jogos na seção de guias pedagógicos

troca nome playground para laboratório e adiciona imagens do lab

adiciona documentação de conceitos básicos de programação

ajustado pequenos erros de digitação

adiciona tooltip com conceitos escondidos em hover na tag +N de conceitos

update docs dev

desativar tour

setup matriz MoleMash

setup matriz MoleMash

fix: link

update version

update docs

update docs

mudou o layout de quem somos

mudei as imgs dos icons e baixei o botao

centraliza titulo com imagem e ajusta sessão com gradiente vermelho-rosa

adiciona responsividade para a pagina quem somos

ajusta botão de conheça nossa história

ajustes

ajustes na home + add. teclado

update version

security

security

feat: add tapume para telas pequenas

v1.1.0

feat: decoda offline

feat: doc offline

offline

fix: ajustes para release

fix: navbar; config ordenação; versão

fix: rotas docs e jupyter para pwa

delete private files

Co-authored-by: Indra Araujo <indra.araujo.santos@gmail.com>
Co-authored-by: solange dos santos <sollangelive71@gmail.com>
This commit is contained in:
Rui Moraes
2025-10-29 21:30:14 -03:00
committed by Graciano
parent e24ee22b5a
commit 3da7d323e8
577 changed files with 121994 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

456
jupyter/content/Python_Básico_Aula_01.ipynb Normal file
View File

@@ -0,0 +1,456 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "7OABYY5Uw1IG"
},
"source": [
"# Aula 01 - Noções Básicas de Python\n",
"## **1. Introdução - O que é Python e por que aprender?**\n",
"\n",
"### **Para que serve a programação ?**\n",
"Programação é um conjunto de instruções determinados pelo programador que descrevem tarefas a serem realzadas pela máquina e atendem diversas finalidades para controlar o comportamento físico de lógico de uma máquina.\n",
"\n",
"Essas instruções são um conjunto das regras\n",
"e procedimentos lógicos que levam à solução\n",
"de um problema em um número finito de\n",
"etapas e de maneira sistemática.\n",
"\n",
"### **Por que ser programador ?**\n",
"- Profissão com alta demanda\n",
"- Mercado em ascensão\n",
"- Salários competitivos\n",
"- Possibilidade de trabalho remoto\n",
"- Resolve problemas mais rápido\n",
"- Desenvolve criatividade\n",
"- Espírito de comunidade\n",
"- Aprendizado contínuo\n",
"\n",
"\n",
"\n",
"### **O que é Python e por que aprender ?**\n",
"\n",
"Python é uma linguagem de programação versátil e de fácil aprendizado. Além disso é Open-Source (código aberto) e utilizada em diversas áreas do conhecimento e aplicações.\n",
"\n",
"É interessante aprender Python por ser uma linguagem fácil de ler e escrever, versátil, com grande comunidade e ecosssistema rico (Há muitas bibliotecas e frameworks!).\n",
"\n",
"\n",
"\n",
"### **EMPRESAS QUE USAM PYTHON**\n",
"\n",
"| | | | |\n",
"|---|---|---|---|\n",
"| <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/e/e7/Instagram_logo_2016.svg/200px-Instagram_logo_2016.svg.png\" width=\"60\"> | <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/7/75/Netflix_icon.svg/200px-Netflix_icon.svg.png\" width=\"60\"> | <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/0/08/Pinterest-logo.png/200px-Pinterest-logo.png\" width=\"60\">\n",
"| **Instagram** | **Netflix** | **Pinterest** |\n",
"\n",
"| | | |\n",
"|---|---|---|\n",
"| <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/1/19/Spotify_logo_without_text.svg/200px-Spotify_logo_without_text.svg.png\" width=\"60\"> | <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/7/78/Dropbox_Icon.svg/200px-Dropbox_Icon.svg.png\" width=\"60\"> | <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/c/cc/Uber_logo_2018.png/200px-Uber_logo_2018.png\" width=\"60\"> |\n",
"| **Spotify** | **Dropbox** | **Uber** |\n",
"\n",
"---\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "6Zf90IVwZ0kH"
},
"source": [
"## **2. O que é um algoritmo?**\n",
"Um algoritmo é uma sequência de instruções para resolver um problema.\n",
"\n",
"**Exemplo: Preparando um café**\n",
"- Passo 01: Encha de água a panela;\n",
"- Passo 02: Coloque a água para ferver;\n",
"- Passo 03: Prepare o porta-filtro;\n",
"- Passo 04: Se houver café, coloque duas duas colheres de sopa de café no filtro;\n",
"- Passo 05: Se não houver café, desligue o fogo e vá atrás de café e repita as etapas 2,3 e 5;\n",
"- Passo 06: Após a água ter fervido, acrescente aos poucos meio litro de água sobre o filtro;\n",
"- Passo 07: Aguarde coar;\n",
"- Passo 08: Adoce a gosto."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ku3roDWV3Xlf"
},
"source": [
"## **3. Engatinhando na linguagem e algumas noções básicas**\n",
"\n",
"### 3.1 **Seu primeiro programa Python !**\n",
"\n",
"O \"Hello World\" é um programa que utiliza o comando de 'Print' (Imprimir ) que imprime informações na tela. Parece ter pouca utilidade mas é uma parada obrigatória ao iniciar em uma nova linguagem, por ser um dos programas mais simples de realizar, acabou se tornando um rito entre os programadores para testar se etá tudo certo. Aqui está seu exemplar em Python. Aperte o botão de \"▶️\" para testar o trecho de código abaixo:\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "yUUmWfX4bfzE",
"outputId": "f5963681-0378-4c48-8cb1-ebe6f2cd95e6"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Olá, esse é meu primeiro programa me Python ! ^^ \n"
]
}
],
"source": [
"# Um programa simples em Python, conhecido como \"Hello World\" ou \"Olá mundo\", imprime um texto na tela:\n",
"print(\"Olá, esse é meu primeiro programa me Python ! ^^ \")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2979d0_n49hg"
},
"source": [
"### 3.2 **Comentários**\n",
"Comentários são textos que o interpretador Python irá ignorar. Servem para explicar o código ou deixar lembrestes. É uma forma muito útil de se organizar ao desenvolver aplicações com muitas linhas de código.\n",
"\n",
"Para inserir um comentário em Python, basta inserir um '#' antes do texto."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "NJOmHUzQ4f_Q"
},
"outputs": [],
"source": [
"# Olá, eu sou um comentário Python !"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "yPbKmjg369Xf"
},
"source": [
"### 3.3 **Variáves**\n",
"\n",
"Variáveis são espaços na memória do computador que armazenam algum tipo de dado que pode ou não ser modificado durante a execução do algoritmo. Imagine uma caixa que guarda algum tipo de informação.\n",
"\n",
"O programa a seguir mostra uma variável \"X\" sendo declarada e tendo um valor de \"10\" atribuído a ela. Caso essa variável seja maior ou igual a 5, o programa irá imprimir na tela a mensagem com essa confirmação, caso não, exibirá a mensagem indicando que o valor de \"X\" é menor do que 5.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "pq_AfEcRfk-G",
"outputId": "38feccb5-3fff-4776-82e5-978374908dbb"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"X é maior ou igual a 5\n"
]
}
],
"source": [
"x = 10 #Momento em que a variável é declarada. Variáveis podem ser declaradas antes e durante a execução do algoritmo;\n",
"if x>=5: #Estrutura lógica \"if\" ou \"se\", condição de que se X for maior do que 5, algo irá acontecer.\n",
" print(\"X é maior ou igual a 5\") #Saída do programa caso X seja maior do que 5\n",
"else:\n",
" print(\"X é menor que 5\") #Saída do programa caso X seja menor do que 5"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "0Nm5rJi2hCVX"
},
"source": [
"## 💡 DICA: Experimente mudar o valor de 5 atribuído a variável X, rode a célula novamente e observe as outras possibilidades de saída."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ButSdTt2824g"
},
"source": [
"### 3.4 **Tipos de dados**\n",
"\n",
"Em geral em linguagens de programação é necessário definir um tipo de dado para se guardar uma variável. Felizmente o Python é uma linguagem dinâmica e consegue definir sem necessidade de declaração.\n",
"\n",
"Porém, para bom uso em aplicações é importante conhecer os diferentes tipos de dados, alguns dos mais importantes estão dispostos na tabela:\n",
"\n",
"<div align=\"center\">\n",
"\n",
"| Tipo | Nome | Exemplo | Descrição |\n",
"|:----:|:----:|:-------:|-----------|\n",
"| **int** | Inteiro | `42`, `-3`, `1000` | Números inteiros (positivos ou negativos) |\n",
"| **float** | Decimal | `3.14`, `-0.5`, `2.0` | Números com casas decimais |\n",
"| **str** | String | `\"Python\"`, `'Olá'` | Texto (entre aspas) |\n",
"| **bool** | Booleano | `True`, `False` | Verdadeiro ou Falso |\n",
"| **list** | Lista | `[1, 2, 3]` | Coleção ordenada e mutável |\n",
"| **tuple** | Tupla | `(1, 2, 3)` | Coleção ordenada e imutável |\n",
"| **dict** | Dicionário | `{\"nome\": \"João\"}` | Pares chave-valor |\n",
"| **set** | Conjunto | `{1, 2, 3}` | Coleção não ordenada sem duplicatas |\n",
"| **NoneType** | Nulo | `None` | Ausência de valor |\n",
"\n",
"</div>\n",
"\n",
"\n",
"Abaixo está um pequeno exemplo de um programa que guardará informações sobre uma pessoa, com a divisão de dados por tipo adequada."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "yt6n80FS61so",
"outputId": "31e969b4-95ff-40b3-ffb6-e3d5c89392be"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Nome: Dominic\n",
"Idade: 24\n",
"Altura: 1.65\n",
"É estudante? True\n"
]
}
],
"source": [
"nome = \"Gui\" # String (texto)\n",
"idade = 24 # Inteiro (número inteiro)\n",
"altura = 1.75 # Float (número decimal)\n",
"estudante = True # Boolean (True ou False)\n",
"\n",
"print(\"Nome:\", nome)\n",
"print(\"Idade:\", idade)\n",
"print(\"Altura:\", altura)\n",
"print(\"É estudante?\", estudante)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "phaK3FrPjcR3"
},
"source": [
"### O exemplo a seguir mostra de maneira mais completa diferentes tipos de dados em possíveis aplicações:\n",
"Esse programa declara variáveis e imprime na tela o seu tipo, experimente rodar para ver na prática o que cada tipo de variável pode representar."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "roXkHc0oELrZ",
"outputId": "3238f661-e005-472c-8fb4-b002946d1a79"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"int: 25 -> <class 'int'>\n",
"float: 1.75 -> <class 'float'>\n",
"str: Maria -> <class 'str'>\n",
"bool: True -> <class 'bool'>\n",
"list: ['maçã', 'banana'] -> <class 'list'>\n",
"tuple: (10, 20) -> <class 'tuple'>\n",
"dict: {'nome': 'João', 'idade': 30} -> <class 'dict'>\n",
"set: {1, 2, 3} -> <class 'set'>\n",
"NoneType: None -> <class 'NoneType'>\n"
]
}
],
"source": [
"\n",
"# int (inteiro)\n",
"idade = 25\n",
"print(f\"int: {idade} -> {type(idade)}\")\n",
"\n",
"# float (decimal)\n",
"altura = 1.75\n",
"print(f\"float: {altura} -> {type(altura)}\")\n",
"\n",
"# str (string/texto)\n",
"nome = \"Maria\"\n",
"print(f\"str: {nome} -> {type(nome)}\")\n",
"\n",
"# bool (booleano)\n",
"aprovado = True\n",
"print(f\"bool: {aprovado} -> {type(aprovado)}\")\n",
"\n",
"# list (lista)\n",
"frutas = [\"maçã\", \"banana\"]\n",
"print(f\"list: {frutas} -> {type(frutas)}\")\n",
"\n",
"# tuple (tupla)\n",
"coordenadas = (10, 20)\n",
"print(f\"tuple: {coordenadas} -> {type(coordenadas)}\")\n",
"\n",
"# dict (dicionário)\n",
"pessoa = {\"nome\": \"João\", \"idade\": 30}\n",
"print(f\"dict: {pessoa} -> {type(pessoa)}\")\n",
"\n",
"# set (conjunto)\n",
"numeros = {1, 2, 3}\n",
"print(f\"set: {numeros} -> {type(numeros)}\")\n",
"\n",
"# NoneType\n",
"vazio = None\n",
"print(f\"NoneType: {vazio} -> {type(vazio)}\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "GUOGzcG_kI5_"
},
"source": [
"## **4. Operadores Matemáticos em Python**\n",
"\n",
"\n",
"### **4.1 Introdução aos Operadores Aritméticos**\n",
"\n",
"Os operadores matemáticos em Python funcionam de forma similar à matemática que você já conhece! Eles permitem realizar cálculos como soma, subtração, multiplicação, divisão entre outras operações...\n",
"\n",
"\n",
"\n",
"## **Operadores Matemáticos:**\n",
"\n",
"<div align=\"center\">\n",
"\n",
"| Operador | Nome | Exemplo | Resultado | Descrição |\n",
"|:--------:|:----:|:-------:|:---------:|-----------|\n",
"| `+` | Adição | `10 + 3` | `13` | Soma dois valores |\n",
"| `-` | Subtração | `10 - 3` | `7` | Subtrai o segundo do primeiro |\n",
"| `*` | Multiplicação | `10 * 3` | `30` | Multiplica dois valores |\n",
"| `/` | Divisão | `10 / 3` | `3.3333` | Divisão com resultado decimal |\n",
"| `//` | Divisão Inteira | `10 // 3` | `3` | Divisão com resultado inteiro |\n",
"| `%` | Módulo (Resto) | `10 % 3` | `1` | Resto da divisão |\n",
"| `**` | Potência | `10 ** 3` | `1000` | Eleva à potência |\n",
"\n",
"</div>\n",
"\n",
"Abaixo está um pequeno exemplo para demonstrar os operadores:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "XHL8ToacEkh3",
"outputId": "a8f4d69a-5e45-40b4-b8ad-19812f3a111f"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a = 10, b = 3\n",
"Soma: 10 + 3 = 13\n",
"Subtração: 10 - 3 = 7\n",
"Multiplicação: 10 * 3 = 30\n",
"Divisão: 10 / 3 = 3.3333333333333335\n",
"Divisão inteira: 10 // 3 = 3\n",
"Resto da divisão: 10 % 3 = 1\n",
"Potência: 10 ** 3 = 1000\n"
]
}
],
"source": [
"# Operadores básicos\n",
"a = 10\n",
"b = 3\n",
"\n",
"print(f\"a = {a}, b = {b}\")\n",
"print(f\"Soma: {a} + {b} = {a + b}\")\n",
"print(f\"Subtração: {a} - {b} = {a - b}\")\n",
"print(f\"Multiplicação: {a} * {b} = {a * b}\")\n",
"print(f\"Divisão: {a} / {b} = {a / b}\")\n",
"print(f\"Divisão inteira: {a} // {b} = {a // b}\")\n",
"print(f\"Resto da divisão: {a} % {b} = {a % b}\")\n",
"print(f\"Potência: {a} ** {b} = {a ** b}\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "M1hWR6tBfpBa"
},
"source": [
"### Importante: Números vs Textos\n",
"\n",
"Existe uma diferença fundamental entre **números** e **textos** (strings):\n",
"\n",
"- **2** é um número (pode ser usado em operações matemáticas)\n",
"- **\"2\"** é um texto (não pode ser usado em operações matemáticas)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "0RHV3IB8fwVI"
},
"outputs": [],
"source": [
"# Diferença entre número e texto\n",
"print(f\"2 + 2 (números) = {2 + 2}\")\n",
"print(f\"'2' + '2' (textos) = {'2' + '2'}\") # Concatenação (junção de textos)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "p-nTQ5JvkzNb"
},
"source": [
"## Conceitos Complementares\n",
"\n",
"- **Ordenação**: organização de listas de palavras ou números\n",
"- **Indentação**: recuo no texto (fundamental em Python para definir blocos de código)\n",
"- **Compilação**: tradução da linguagem de programação para linguagem de máquina"
]
}
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"name": "python3"
},
"language_info": {
"name": "python"
}
},
"nbformat": 4,
"nbformat_minor": 0
}

161
jupyter/content/Python_Básico_Aula_02.ipynb Normal file
View File

@@ -0,0 +1,161 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "7WkjuZNVmW4n"
},
"source": [
"# Aula 02 - Estruturas Lógicas\n",
"## **Avançando na Lógica: Estruturas condicionais e de repetição**"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "7oLa0x1amTpx"
},
"source": [
"## 1.Estruturas Condicionais\n",
"\n",
"### 1.1 O que são estruturas condicionais ?\n",
"\n",
"\n",
"Nos nossos problemas muitas vezes podemos dividir as questões\n",
"em “sim” ou “não”, mas isso pode gerar cadeias grandes de maneira\n",
"desnecessária. E mesmo assim, nem sempre isso dará conta para\n",
"resolução dos nossos problemas. Para problemas mais complexos\n",
"utilizamos o “se” (if) e o “senão” (else). Essas duas palavras são o\n",
"que chamamos de condicionais, usamos ela quando queremos\n",
"colocar uma condição para tal coisa acontecer.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "PZBMCUgslFzC"
},
"source": [
"## 1.2 A estrutura condicional `if`\n",
"\n",
"O if é uma estrutura de condição que permite avaliar uma expressão e, de acordo com seu resultado, executar uma determinada ação.\n",
"\n",
"No código a seguir temos um exemplo de uso do if no qual verificamos se a a previsão é de chuva ou não, caso seja afirmativo, o programa imprime na tela a mensagem \"Levo galocha\"."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "H63C4Zw9erXs"
},
"outputs": [],
"source": [
"# Exemplo de estrutura condicional\n",
"previsao = \"chuva\"\n",
"\n",
"if previsao == \"chuva\":\n",
" print(\"Levo galocha\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2fA0lEdjlvai"
},
"source": [
"## 1.2 A estrutura condicional `if-else`\n",
"\n",
"A estrutura \"if\" do exemplo anterior executou uma ação em caso de uma condição ser atendida, mas não supre para caso a ação não seja satisfeita. Nesse caso, podemos utilizar a condicional `else`"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "s2Vr3We0lBM7",
"outputId": "4ad95c2e-d136-490b-bc11-14e01e379fb3"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Levo Tênis\n"
]
}
],
"source": [
"previsao = \"chuva\"\n",
"\n",
"if previsao == \"chuva\":\n",
" print(\"Levo galocha\")\n",
"else:\n",
" print(\"Levo Tênis\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "VJn9unI1e1sC"
},
"source": [
"## 2. Condicionais Encadeadas\n",
"\n",
"Podemos ter múltiplas condições usando `elif` (else if) para criar cadeias de decisões mais complexas."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "K9GNrtIvfCUZ",
"outputId": "289fdd0a-58e9-4117-d946-5984d1e94f34"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Carne assada\n"
]
}
],
"source": [
"# Exemplo de condicional encadeada\n",
"dia = \"terça\"\n",
"\n",
"if dia == \"segunda\":\n",
" print(\"Virado à paulista\")\n",
"elif dia == \"terça\":\n",
" print(\"Carne assada\")\n",
"elif dia == \"quarta\":\n",
" print(\"Feijoada\")\n",
"elif dia == \"quinta\":\n",
" print(\"Lasanha à bolonhesa\")\n",
"else:\n",
" print(\"Verificar cardápio\")"
]
}
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"name": "python3"
},
"language_info": {
"name": "python"
}
},
"nbformat": 4,
"nbformat_minor": 0
}

488
jupyter/content/Python_Básico_Aula_03.ipynb Normal file
View File

@@ -0,0 +1,488 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "S1tTxhT7d2IR"
},
"source": [
"# Aula 03 - Estruturas de Repetição e Boas Práticas de Programação\n",
"## **Avançando na Lógica: Estruturas condicionais e de repetição**"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "etqOZVrDd5AY"
},
"source": [
"## 1. Indentação\n",
"\n",
"**Indentação** é um recuo no texto (tab ou dois espaços) que serve para ressaltar e, em muitas linguagens como Python, **definir a estrutura do algoritmo**.\n",
"\n",
"Em Python, a indentação é obrigatória para definir blocos de código."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "DCHoZ5PwiSlU"
},
"outputs": [],
"source": [
"# Exemplo correto de indentação\n",
"if True:\n",
" print(\"Este bloco está indentado corretamente\")\n",
" print(\"Tudo aqui dentro faz parte do if\")\n",
"print(\"Este print está fora do bloco if\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "s6W6PsN5e01Q"
},
"source": [
"## 2. Comando `input()`\n",
"\n",
"O comando `input()` **pede para o usuário digitar alguma informação** durante a execução do programa."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "RYLxHFmqe0b_"
},
"outputs": [],
"source": [
"# Exemplo com input\n",
"teste = input(\"sim ou não? \")\n",
"if teste == \"sim\":\n",
" print(\"Olá Mundo\")\n",
"else:\n",
" print(\"Olá Brasil\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "-TlRMpEEjygB"
},
"source": [
"## 3. Loop For (Para)\n",
"\n",
"O `for` é uma estrutura de repetição utilizada para **iterar sobre sequências** ou executar um bloco de código **um número determinado de vezes**.\n",
"\n",
"### Sintaxe básica:\n",
"```python\n",
"for variável in sequência:\n",
" # bloco de código"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "iO4IUfwZj9Na"
},
"outputs": [],
"source": [
"# Exemplo básico: percorrendo uma lista\n",
"frutas = [\"maçã\", \"banana\", \"laranja\", \"uva\"]\n",
"\n",
"for fruta in frutas:\n",
" print(f\"Eu gosto de {fruta}\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "QPEKsfOckJ6A"
},
"source": [
"## 4. Função range()\n",
"\n",
"A função `range()` gera uma sequência de números e é muito usada com o `for`.\n",
"\n",
"### Formas de usar range():\n",
"- `range(stop)` - números de 0 até stop-1\n",
"- `range(start, stop)` - números de start até stop-1\n",
"- `range(start, stop, step)` - números de start até stop-1, pulando de step em step"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "ta2yZ6AHkNgZ"
},
"outputs": [],
"source": [
"# range com um argumento (stop)\n",
"print(\"range(5):\", end=\" \")\n",
"for i in range(5):\n",
" print(i, end=\" \")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "ncTaXOZBkQN4"
},
"outputs": [],
"source": [
"# range com dois argumentos (start, stop)\n",
"print(\"range(2, 7):\", end=\" \")\n",
"for i in range(2, 7):\n",
" print(i, end=\" \")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pGX5gsHHe6y_"
},
"source": [
"## 4. Loop while (enquanto)\n",
"\n",
"O comando `while` cria **loops de repetição**. Os comandos dentro do while se repetem **até que a expressão lógica seja falsa**."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "XzHTmyRMjbQI"
},
"source": [
"### Comandos importantes em loops:\n",
"- **break**: interrompe o loop\n",
"- **continue**: pula para a próxima iteração\n",
"- **pass**: não faz nada"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "fE-jQYn1e9Dv"
},
"outputs": [],
"source": [
"# Exemplo básico de while\n",
"contador = 0\n",
"while contador < 3:\n",
" print(f\"Volta número {contador + 1}\")\n",
" contador += 1"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "k3DgtgMHjtRZ"
},
"outputs": [],
"source": [
"# Exemplo com break e continue\n",
"print(\"Exemplo com break e continue:\")\n",
"\n",
"for i in range(1, 6):\n",
" if i == 3:\n",
" print(\" Pulei o 3 (continue)\")\n",
" continue\n",
" if i == 5:\n",
" print(\" Parei no 5 (break)\")\n",
" break\n",
" print(f\" Número: {i}\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "xyQWY_PnfAlP",
"outputId": "238331eb-675b-471a-f9ed-437ea100deac"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"sim ou não? sim\n",
"Olá Mundo\n",
"Continua? sim\n",
"Olá Mundo\n",
"Continua? sim\n",
"Olá Mundo\n",
"Continua? não\n",
"Loop encerrado!\n"
]
}
],
"source": [
"# Exemplo interativo com while\n",
"teste = input(\"sim ou não? \")\n",
"while teste == \"sim\":\n",
" print(\"Olá Mundo\")\n",
" teste = input(\"Continua? \")\n",
"print(\"Loop encerrado!\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "54vMwwZWfJrR"
},
"outputs": [],
"source": [
"# Exemplo mais elaborado com while\n",
"acampado = input(\"Participa? (sim/não) \")\n",
"\n",
"while acampado == \"não\":\n",
" print(\"é andorinha!\")\n",
" print(\"tá perdendo tempo!\")\n",
" acampado = input(\"Participa? (sim/não) \")\n",
"\n",
"if acampado == \"sim\":\n",
" print(\"É de luta!\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3TzHt2CHfMjK"
},
"source": [
"## 5. Erros Comuns em Python\n",
"\n",
"### 5.1 Erro de Indentação\n",
"Quando não indentamos corretamente os blocos de código."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "il5QuKkufSaX"
},
"outputs": [],
"source": [
"# Código com erro de indentação (comentado para não travar a execução)\n",
"\"\"\"\n",
"teste = input(\"Sim ou não? \")\n",
"if teste == \"sim\":\n",
"print(\"A resposta é sim!\") # Esta linha deveria estar indentada!\n",
"else:\n",
"print(\"A resposta é não!\") # Esta linha deveria estar indentada!\n",
"\"\"\"\n",
"print(\"Exemplo de erro: IndentationError: expected an indented block\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "cDMCLOurfUqQ"
},
"source": [
"### 5.2 Variável não declarada\n",
"Quando tentamos usar uma variável que não foi criada."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "o_6tWWregHJZ"
},
"outputs": [],
"source": [
"# Exemplo de erro de variável não declarada\n",
"# print(teste) # Isso daria erro se executado (NameError)\n",
"\n",
"# Correção:\n",
"teste = \"Agora a variável existe\"\n",
"print(teste)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "FUSvSuvlgLHn"
},
"source": [
"### 5.3 Erro de Sintaxe - Variável vazia\n",
"Quando tentamos criar uma variável sem atribuir um valor."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "rix1x482gMOw"
},
"outputs": [],
"source": [
"# Exemplo de sintaxe inválida\n",
"# teste = # Isso causaria SyntaxError\n",
"\n",
"print(\"Exemplo de erro: SyntaxError: invalid syntax\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "-taEvF9Rgac4"
},
"source": [
"### 5.4 Erro de Sintaxe - Estrutura do if\n",
"Quando esquecemos os dois pontos `:` após a condição do if."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "3E0EK6Nygbho"
},
"outputs": [],
"source": [
"# Exemplo de erro na estrutura do if\n",
"\"\"\"\n",
"teste = input(\"Sim ou Não? \")\n",
"if teste == \"sim\" # Faltam os dois pontos (:)\n",
" print(\"A resposta é sim!\")\n",
"\"\"\"\n",
"print(\"Exemplo de erro: if sem dois pontos causa SyntaxError\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "N-lMxfs0gfF4"
},
"source": [
"## 6. Avançando nos Operadores Matemáticos: Comparação\n",
"\n",
"### Diferença entre = e ==\n",
"\n",
"- **=** (atribuição): usado para **atribuir** um valor a uma variável\n",
" - Exemplo: `boomer = \"Gabriel\"`\n",
"\n",
"- **==** (igualdade): usado para **comparar** se dois valores são iguais\n",
" - Exemplo: `7 == 7` (verdadeiro), `\"sim\" == \"sim\"` (verdadeiro)\n",
"\n",
"- **!=** (diferente): usado para verificar se dois valores são **diferentes**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "s-d7rumlglhr"
},
"outputs": [],
"source": [
"# Exemplos de operadores de comparação\n",
"print(f\"7 == 7: {7 == 7}\")\n",
"print(f\"1 == 1: {1 == 1}\")\n",
"print(f\"'sim' == 'sim': {'sim' == 'sim'}\")\n",
"print(f\"7 != 5: {7 != 5}\")\n",
"print(f\"'sim' != 'não': {'sim' != 'não'}\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3vuRTx-jgpzP"
},
"source": [
"## 7. Exemplos Práticos\n",
"\n",
"Vamos ver alguns exemplos que combinam vários conceitos aprendidos:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "rdzXdffXgq2C"
},
"outputs": [],
"source": [
"# Exemplo 1: Calculadora simples com validação\n",
"print(\"=== CALCULADORA SIMPLES ===\")\n",
"numero1 = float(input(\"Digite o primeiro número: \"))\n",
"numero2 = float(input(\"Digite o segundo número: \"))\n",
"\n",
"soma = numero1 + numero2\n",
"print(f\"A soma de {numero1} + {numero2} = {soma}\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "FuMye02xgsZY"
},
"outputs": [],
"source": [
"# Exemplo 2: Verificador de idade com loop\n",
"print(\"=== VERIFICADOR DE IDADE ===\")\n",
"\n",
"while True:\n",
" idade = input(\"Digite sua idade (ou 'sair' para encerrar): \")\n",
"\n",
" if idade.lower() == \"sair\":\n",
" print(\"Programa encerrado!\")\n",
" break\n",
"\n",
" idade = int(idade)\n",
" if idade >= 18:\n",
" print(\"Maior de idade\")\n",
" else:\n",
" print(\"Menor de idade\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "UdxOJf7agujI"
},
"outputs": [],
"source": [
"# Exemplo 3: Comparação de textos\n",
"print(\"=== COMPARAÇÃO DE TEXTOS ===\")\n",
"\n",
"palavra1 = input(\"Digite a primeira palavra: \")\n",
"palavra2 = input(\"Digite a segunda palavra: \")\n",
"\n",
"if palavra1 == palavra2:\n",
" print(\"As palavras são IGUAIS\")\n",
"else:\n",
" print(\"As palavras são DIFERENTES\")"
]
}
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"name": "python3"
},
"language_info": {
"name": "python"
}
},
"nbformat": 4,
"nbformat_minor": 0
}