0 Fundamentos — Módulo completo

📖 Glossário - Fundamentos

A

Algoritmo: Sequência finita de instruções bem definidas para resolver um problema ou executar uma tarefa.

API (Application Programming Interface): Interface que permite que diferentes softwares se comuniquem entre si.

ASCII: Padrão de codificação de caracteres que usa números de 0 a 127 para representar letras, números e símbolos.

B

Biblioteca (Library): Coleção de código pré-escrito que pode ser reutilizado em diferentes programas.

Bug: Erro ou defeito em um programa que causa comportamento inesperado.

Byte: Unidade de informação digital que consiste em 8 bits, capaz de representar 256 valores diferentes.

C

Código-fonte: Texto escrito em uma linguagem de programação que será compilado ou interpretado.

Compilador: Programa que traduz código-fonte em linguagem de máquina executável.

Console: Interface de linha de comando onde você pode executar comandos e ver resultados.

D

Debugging: Processo de encontrar e corrigir bugs (erros) em um programa.

Diretório: Pasta no sistema de arquivos que organiza arquivos e outras pastas.

Documentação: Textos explicativos sobre como usar um software, biblioteca ou framework.

E

Editor de código: Software especializado para escrever e editar código-fonte (ex: VS Code, PyCharm).

Encoding: Sistema de codificação que define como caracteres são representados digitalmente (UTF-8, ASCII, etc).

Executável: Arquivo que pode ser executado diretamente pelo sistema operacional.

F

Framework: Estrutura de software que fornece funcionalidades genéricas e pode ser especializada para aplicações específicas.

Função: Bloco de código reutilizável que executa uma tarefa específica.

G

Git: Sistema de controle de versão distribuído para rastrear mudanças no código.

GitHub: Plataforma de hospedagem de código-fonte usando Git.

GUI (Graphical User Interface): Interface gráfica com botões, menus e janelas (oposto de linha de comando).

H

HTML (HyperText Markup Language): Linguagem de marcação para criar páginas web.

HTTP (HyperText Transfer Protocol): Protocolo de comunicação para transferência de dados na web.

I

IDE (Integrated Development Environment): Ambiente completo para desenvolvimento com editor, debugger e ferramentas integradas.

Intérprete: Programa que executa código-fonte diretamente, linha por linha, sem compilação prévia.

IP (Internet Protocol): Protocolo que define como dados são enviados pela internet.

J

JSON (JavaScript Object Notation): Formato leve de intercâmbio de dados legível por humanos e máquinas.

L

Linguagem de programação: Sistema formal para escrever instruções que computadores podem executar (Python, JavaScript, etc).

Loop: Estrutura de repetição que executa código múltiplas vezes.

M

Markdown: Linguagem de marcação leve para formatação de texto.

Método: Função associada a um objeto ou classe em programação orientada a objetos.

Módulo: Arquivo contendo definições e instruções Python que podem ser importadas.

O

Open Source: Software com código-fonte disponível publicamente para uso e modificação.

Operador: Símbolo que realiza operações matemáticas ou lógicas (+, -, *, /, ==, etc).

P

Pacote (Package): Coleção organizada de módulos Python.

Path (Caminho): Localização de um arquivo ou diretório no sistema de arquivos.

pip: Gerenciador de pacotes do Python para instalar bibliotecas.

Prompt de comando: Interface de texto onde você digita comandos para o sistema operacional.

Python: Linguagem de programação de alto nível, interpretada e de propósito geral.

R

README: Arquivo com informações básicas sobre um projeto (instruções, documentação inicial).

Repositório: Local onde o código-fonte e histórico de versões são armazenados (Git).

REPL (Read-Eval-Print Loop): Ambiente interativo que lê comandos, executa e mostra resultados.

S

Script: Programa geralmente curto e específico para automatizar tarefas.

Shell: Interface de linha de comando para interagir com o sistema operacional.

Sintaxe: Conjunto de regras que define como escrever código corretamente em uma linguagem.

T

Terminal: Aplicativo que fornece acesso ao shell (linha de comando).

Tipo de dado: Classificação de dados (inteiro, string, lista, etc) que define operações possíveis.

U

URL (Uniform Resource Locator): Endereço que especifica a localização de um recurso na web.

UTF-8: Sistema de codificação de caracteres que suporta todos os caracteres Unicode.

V

Variável: Nome que armazena um valor que pode mudar durante a execução do programa.

Versão: Identificação de um estado específico do software (ex: Python 3.12.1).

Virtual Environment (venv): Ambiente Python isolado com suas próprias dependências.

W

Web: Sistema de páginas interligadas acessíveis pela internet.

Workspace: Pasta ou conjunto de pastas onde você trabalha em um projeto.

💡 Dica: Este glossário será expandido conforme você avança nos módulos. Termos técnicos serão explicados em contexto quando aparecerem pela primeira vez!

🚀 Introdução - Programação para Biologia e Oceanografia

Bem-vindo!

Você já se perguntou como scientists e pesquisadores usam programação para: - 🗺️ Mapear ecossistemas marinhos? - 📊 Analisar dados de biodiversidade? - 🧬 Processar imagens de microscopia? - 🌊 Monitorar mudanças costeiras?

Parabéns! Você está no lugar certo! Este tutorial vai te ensinar as ferramentas que os cientistas modernos usam.

🎯 O que você vai aprender?

Nível 1 - Técnico (IFSC, ETIM)

• Conceitos básicos de programação
• Automação de tarefas
• Visualização de dados simples
• Uso de ferramentas open-source

Nível 2 - Graduação (UFSC)

• Análise de dados com Python
• Mapas interativos com JavaScript
• Processamento de dados geoespaciais
• Pesquisa reproduzível

Nível 3 - Pós-graduação (Mestrado)

• Pipelines de análise avançados
• Dashboards profissionais
• Automação de coleta de dados
• Publicação de resultados online

💻 Ferramentas que você dominará

┌─────────────────────────────────────────┐
│         PILARES DO SEU APRENDIZADO       │
├─────────────────────────────────────────┤
│ 🐍 Python        → Análise de dados      │
│ 🗺️ Geoespacial  → Mapas e SIG           │
│ 📊 Visualização → Gráficos interativos  │
│ 🌐 Web          → Publicar resultados   │
│ 🔧 Automação    → Workflows eficientes  │
└─────────────────────────────────────────┘

📚 Estrutura deste Tutorial

0-FUNDAMENTOS (VOCÊ ESTÁ AQUI!)
├── 01-Introducao ← Você agora!
├── 02-Configurar-Ambiente (próximo)
└── 03-Conceitos-Basicos

1-PYTHON-ESSENCIAL
├── 01-Sintaxe-Basica
├── 02-Estruturas-Dados
└── 03-Funcoes-Modulos

2-ANALISE-GEOESPACIAL
├── 01-GeoJSON-Basico
├── 02-GeoPandas-Intro
└── 03-Mapas-Leaflet

3-VISUALIZACAO-WEB
├── 01-HTML5-Basico
├── 02-JavaScript-Essencial
└── 03-Folium-Interativo

4-CASOS-PRATICOS
├── 01-Monitoramento-Costeiro
├── 02-Distribuicao-Macroalgas
└── 03-Analise-Biodiversidade

🌍 Exemplos do Mundo Real (Seu Contexto - LAFIC)

Caso 1: Monitoramento de Macroalgas (LAFIC) 🌿

Você precisa mapear distribuição de Ulva lactuca e Gracilaria na costa de SC.

Cenário sem programação: - ❌ Tabela Excel com 500 amostras - ❌ Copiar/colar coordenadas manualmente - ❌ Mapas estáticos no Google Earth - ❌ Atualizar dados = refazer tudo (semanas!) - ❌ Impossível compartilhar dados dinamicamente

Cenário COM programação: - ✅ CSV automaticamente processado - ✅ Mapas interativos criados em minutos - ✅ Atualizar dados = rodar script (5 min!) - ✅ Publicar online para sua comunidade - ✅ Análises reproduzíveis (pesquisa científica!)

Tempo economizado: 80+ horas/ano

Caso 2: Análise Taxonômica de Ficologia 🧬

Você coleta 2000 amostras de macroalgas para classificação e análise.

Sem programação: - ❌ Anotar espécie, profundidade, temperatura em papel/Excel - ❌ Calcular estatísticas manualmente - ❌ Fazer gráficos um por um (horas!) - ❌ Erros de digitação comuns

Com programação: - ✅ Dados coletados direto em banco de dados - ✅ Análises estatísticas em 1 minuto - ✅ 50+ gráficos gerados automaticamente - ✅ Padrões descobertos por análise (machine learning!) - ✅ Publicar resultados em dashboard online

Resultado: Você passa mais tempo analisando, menos tempo digitando!

Caso 3: Comparação com Pesquisadores Internacionais 🌎

Você quer comparar dados de macroalgas com 10 países.

Sem programação: - ❌ Download datasets separados em diferentes formatos - ❌ Copiar/colar dados em Excel (propenso a erros) - ❌ Integrar manualmente (dias de trabalho!) - ❌ Impossível atualizar quando dados novos saem

Com programação: - ✅ Script baixa dados automaticamente de 10 servidores - ✅ Combina em formato único - ✅ Executa 100 análises simultâneas - ✅ Atualiza automaticamente (roda todo mês) - ✅ Produz relatório final em PDF/HTML

Ganho: Você descobre padrões que humanos não conseguem em Excel!

❓ Perguntas Frequentes

"Preciso ser matemático?"

❌ Não! Começamos do zero. Python foi criado para ser fácil!

"Posso fazer isso no meu computador?"

✅ Sim! Tudo é GRÁTIS e open-source. Funciona em Windows, Mac, Linux.

"Quanto tempo leva?"

• Fundamentos: 1-2 semanas
• Python + Análise: 4-6 semanas
• Geoespacial + Web: 2-3 semanas
• Domínio completo: ~3 meses dedicação

"Preciso aprender programação antes?"

✅ Este tutorial COMEÇA do zero! Sem pré-requisitos!

🛠️ O que você precisa ter

Mínimo obrigatório:

1. Computador (Windows, Mac ou Linux) ✅
2. Conexão internet (para download) ✅
3. Curiosidade (mais importante!) 🧠

Recomendado:

• 30 minutos livres por dia
• Um caderno para anotações
• Café ou chá ☕

🚦 Próximos passos

Sua jornada começa aqui:

📍 Você está aqui
   ↓
02-Configurar-Ambiente (próximo módulo)
   ↓
03-Conceitos-Basicos
   ↓
Pronto para Python! 🎉

💡 Uma Verdade Importante

Todo programador experiente começou exatamente onde você está agora.

O pesquisador que criou o GeoPandas, o desenvolvedor do Leaflet, o inventor do Python...

Todos começaram com "Hello World"

A diferença entre um iniciante e um expert não é inteligência, é prática consistente.

✨ Seu Objetivo Final

Ao terminar este tutorial, você será capaz de:

✅ Ler e processar dados de pesquisa automaticamente
✅ Criar mapas interativos para apresentações
✅ Analisar padrões em dados oceanográficos
✅ Publicar resultados online
✅ Compartilhar código reproduzível com colegas

📖 Filosofia de Aprendizado

Nosso método:

1. Entender por quê (motivação)
2. Ver exemplos (contexto)
3. Fazer na prática (hands-on)
4. Resolver problemas reais (aplicação)
5. Errar e aprender (crescimento)

Esperamos que você:

• Faça perguntas (não há perguntas "bobas")
• Teste tudo (programação é aprenda fazendo)
• Erre (erros são ferramentas de aprendizado)
• Adapte exemplos para seus dados
• Compartilhe descobertas com colegas

🎓 Este Tutorial é Para Você Se...

✅ Trabalha em pesquisa em Biologia ou Oceanografia
✅ Quer analisar dados de forma profissional
✅ Busca automatizar tarefas repetitivas
✅ Quer publicar pesquisa de forma reproduzível
✅ Quer aprender uma habilidade que o mercado valoriza
✅ Simplesmente tem curiosidade!

📞 Suporte e Recursos

Enquanto estuda:

• Exemplos com dados reais de pesquisa
• Código documentado linha por linha
• Problemas para resolver
• Links para documentação oficial

Após terminar:

• Repositório GitHub para seus projetos
• Comunidade de pesquisadores-programadores
• Recursos avançados para aprofundamento

🎯 Seu Primeiro Desafio

Antes de prosseguir para configurar o ambiente, responda a si mesmo:

1. Por que estou aprendendo programação?
2. Qual problema real eu quero resolver?
3. Qual é meu objetivo nos próximos 3 meses?

Escreva suas respostas! Elas motivarão você quando ficar difícil.

➡️ Próximo Passo

👉 Vá para: 02-Configurar-Ambiente.html

Lá você vai: - Instalar as ferramentas necessárias - Fazer seu primeiro programa rodar - Estar pronto para aprender Python!

📝 Resumo desta lição

Bem-vindo à revolução da pesquisa computacional! 🚀

Vamos começar? ➡️

🛠️ Configurar Seu Ambiente de Desenvolvimento

O que é Ambiente de Desenvolvimento?

É um espaço no seu computador onde você escreve, testa e executa programas.

Analogia: - Sem ambiente = tentar fazer culinária sem cozinha - Com ambiente = uma cozinha equipada e organizada ✨

📋 Pré-requisitos

• ✅ Windows 10/11, macOS ou Linux
• ✅ ~10GB de espaço em disco
• ✅ Conexão internet (para download)
• ✅ Paciência de 30 minutos

🎯 Ferramentas que Instalaremos

┌──────────────────────────────────────┐
│    SEU AMBIENTE DE DESENVOLVIMENTO   │
├──────────────────────────────────────┤
│ 1️⃣  Python 3.11+       (linguagem)   │
│ 2️⃣  VS Code            (editor)      │
│ 3️⃣  Git                (versionamento)│
│ 4️⃣  Bibliotecas Python (ferramentas) │
└──────────────────────────────────────┘

🐍 Passo 1: Instalar Python

Windows

1. Visite: https://www.python.org/downloads/
2. Clique em "Download Python 3.11" (ou versão mais recente)
3. Abra o instalador
4. ⚠️ IMPORTANTE: Marque "Add Python to PATH"

[x] Install launcher for all users
[x] Add Python 3.11 to PATH  ← MARQUE ISTO!

1. Clique "Install Now"
2. Aguarde conclusão

Verificar instalação:

Abra o PowerShell e execute:

python --version

Você deve ver:

Python 3.11.x (ou versão mais recente)

macOS

# Via Homebrew (recomendado)
brew install python3

# Verificar
python3 --version

Linux (Ubuntu/Debian)

sudo apt update
sudo apt install python3 python3-pip

python3 --version

💻 Passo 2: Instalar VS Code

O que é VS Code?

Um editor de código moderno onde você escreve seus programas.

Instalação

1. Visite: https://code.visualstudio.com/
2. Baixe a versão para seu SO
3. Instale normalmente
4. Abra VS Code

Extensões Recomendadas

No VS Code, clique em "Extensions" (ícone de quadrado ao lado) e instale:

• Python (Microsoft) - Essencial!
• Pylance - Autocomplete inteligente
• GitLens - Melhor integração Git
• Thunder Client - Testar APIs

🌳 Passo 3: Configurar Pasta de Trabalho

Criar estrutura de pastas

# Windows PowerShell
mkdir $HOME\Documentos\Projetos-Programacao
cd $HOME\Documentos\Projetos-Programacao

# Criar subpastas
mkdir aulas
mkdir projetos
mkdir datasets

Ou criar manualmente no Windows Explorer:

Documentos/
└── Projetos-Programacao/
    ├── aulas/
    ├── projetos/
    └── datasets/

🔄 Passo 4: Instalar Git (Versionamento)

Por que Git?

Rastreia mudanças no seu código. Essencial para pesquisa reproduzível!

Windows

1. Visite: https://git-scm.com/download/win
2. Baixe e instale
3. Use opções padrão

Verificar:

git --version

macOS

brew install git
git --version

Linux

sudo apt install git
git --version

📦 Passo 5: Instalar Bibliotecas Python

As "ferramentas" que você usará para análise de dados.

Abra PowerShell/Terminal

# Windows
python -m pip install --upgrade pip

# Instalar bibliotecas essenciais
pip install numpy pandas matplotlib
pip install geopandas folium
pip install jupyter notebook
pip install requests beautifulsoup4

Verificar Instalação

python

Agora você está em Python. Digite:

import numpy
import pandas
import matplotlib
import geopandas
print("✅ Tudo instalado!")

Se aparecer "✅ Tudo instalado!" sem erros, parabéns! 🎉

Saia do Python:

exit()

🧪 Passo 6: Teste Seu Primeiro Programa

Criar arquivo

1. Abra VS Code
2. Crie arquivo: teste-setup.py
3. Escreva:

# Seu primeiro programa!
print("🎉 Olá, Mundo!")
print("🐍 Python está funcionando!")
print("🎓 Você está pronto para aprender!")

# Testar bibliotecas
import numpy as np
import pandas as pd

dados = [1, 2, 3, 4, 5]
print(f"✅ Numpy funcionando: {np.mean(dados)}")
print(f"✅ Pandas funcionando: v{pd.__version__}")

Executar

No terminal do VS Code (Ctrl + Backtick):

python teste-setup.py

Você deve ver:

🎉 Olá, Mundo!
🐍 Python está funcionando!
🎓 Você está pronto para aprender!
✅ Numpy funcionando: 3.0
✅ Pandas funcionando: v2.x.x

Se viu isso, PARABÉNS! ✨ Seu ambiente está pronto!

🚀 Passo 7: Primeiro Programa com Dados Reais

Agora vamos fazer algo interessante!

Criar: analise-simples.py

import pandas as pd
import numpy as np

# Simular dados de coleta de plâncton
dados_fitoplancton = {
    'Data': ['2025-01-01', '2025-01-02', '2025-01-03'],
    'Densidade': [150, 230, 180],
    'Temperatura': [22.5, 23.1, 22.8],
    'Salinidade': [35.0, 34.8, 35.1]
}

# Criar tabela
df = pd.DataFrame(dados_fitoplancton)

# Análises
print("=" * 50)
print("📊 ANÁLISE DE FITOPLÂNCTON")
print("=" * 50)
print(df)
print("\n📈 Estatísticas:")
print(f"Densidade média: {df['Densidade'].mean():.1f} células/mL")
print(f"Temperatura média: {df['Temperatura'].mean():.1f}°C")
print(f"Salinidade média: {df['Salinidade'].mean():.1f} PSU")

Executar:

python analise-simples.py

Você verá:

==================================================
📊 ANÁLISE DE FITOPLÂNCTON
==================================================
        Data  Densidade  Temperatura  Salinidade
0 2025-01-01        150         22.5        35.0
1 2025-01-02        230         23.1        34.8
2 2025-01-03        180         22.8        35.1

📈 Estatísticas:
Densidade média: 186.7 células/mL
Temperatura média: 22.8°C
Salinidade média: 35.0 PSU

✅ Checklist de Instalação

• [ ] Python 3.11+ instalado e no PATH
• [ ] VS Code instalado com extensão Python
• [ ] Git instalado
• [ ] Pasta de trabalho criada
• [ ] Bibliotecas Python instaladas (numpy, pandas, geopandas, folium)
• [ ] Primeiro programa executado com sucesso
• [ ] Análise simples funcionando

Se tudo estiver marcado, você está pronto! 🎉

⚠️ Troubleshooting

Problema: "python não é reconhecido"

Solução: - Reinstale Python e MARQUE "Add Python to PATH" - Reinicie o computador após instalação

Problema: "ModuleNotFoundError: No module named 'pandas'"

Solução:

pip install pandas

Problema: VS Code não encontra Python

Solução: - Ctrl+Shift+P → "Python: Select Interpreter" - Escolha a versão que você instalou

Problema: Git não aparece no PowerShell

Solução: - Feche e reabra PowerShell após instalar Git

🎓 Próximo Passo

Seu ambiente está configurado! Agora:

👉 Vá para: 03-Conceitos-Basicos.html

Lá você aprenderá: - O que é código? - Como pensa um programador? - Conceitos fundamentais de programação

📝 Resumo

Parabéns por completar a configuração! 🚀

Você agora tem um ambiente profissional de desenvolvimento!

Vamos aprender os conceitos fundamentais? ➡️

🧠 Conceitos Básicos de Programação

O que é Programação?

Programação é dar instruções ao computador em uma linguagem que ele entende.

Analogia com a Vida Real

PESSOAS                          COMPUTADORES
├─ Entende português            ├─ Entende Python, JavaScript, etc
├─ Segue instruções              ├─ Executa código
├─ Toma decisões                 ├─ Segue lógica
└─ Usa ferramentas               └─ Usa bibliotecas

🔤 Linguagens de Programação

Assim como temos português, inglês, espanhol... Temos linguagens de programação!

As principais para Biologia/Oceanografia:

🐍 Python      → Análise de dados (MELHOR PARA COMEÇAR)
🌐 JavaScript  → Mapas interativos web
📊 R           → Estatística avançada
🗺️ SQL         → Bancos de dados

Você vai aprender: Python → JavaScript → GeoJSON/SQL

💾 Informações Básicas (Bits & Bytes)

Antes de entender programação, você precisa entender como computadores armazenam dados.

A Unidade Mais Pequena: Bit

1 bit = 0 ou 1
        Falso ou Verdadeiro
        Desligado ou Ligado

Unidades de Armazenamento

1 Byte         = 8 bits                    (caractere)
1 Kilobyte     = 1.024 bytes              (~1 página)
1 Megabyte     = 1.024 KB                  (~música)
1 Gigabyte     = 1.024 MB                  (~filme)
1 Terabyte     = 1.024 GB                  (~biblioteca)

Exemplo real: - Uma foto do microscópio: ~5 MB - Datasets de pesquisa: 100 MB a 10 GB - Seu computador: 256 GB a 1 TB

📊 Tipos de Dados (O Que o Computador Armazena)

1. Números Inteiros (int)

idade = 25
quantidade = 1000
profundidade = -500  # negativo é permitido

2. Números Decimais (float)

temperatura = 22.5
salinidade = 35.0
pH = 7.8

3. Texto (string)

nome = "Caetano Ronan"
especie = "Ulva lactuca"
localizacao = "Praia dos Ingleses"

4. Verdadeiro/Falso (bool)

coletado = True
analisado = False
valido = True

5. Listas (collections)

especies = ["Ulva lactuca", "Gracilaria", "Sargassum"]
temperaturas = [22.5, 23.1, 22.8]
dados_mistos = [1, "espécie", True, 22.5]

6. Dicionários (dados com rótulo)

amostra = {
    "id": 1,
    "especie": "Ulva lactuca",
    "profundidade": 5.2,
    "temperatura": 22.5,
    "valida": True
}

🔀 Estruturas de Controle

1. Sequência

Executar linhas uma por uma:

# Linha 1
nome = "Oceanógrafo"

# Linha 2
print(nome)  # Printa: "Oceanógrafo"

# Linha 3
profissao = "Pesquisador"

2. Condição (if/else)

Tomar decisões:

temperatura = 22.5

if temperatura > 25:
    print("🌞 Água quente")
elif temperatura > 20:
    print("🌤️ Temperatura ideal para coleta")
else:
    print("❄️ Água fria")

Resultado: "🌤️ Temperatura ideal para coleta"

3. Repetição (loops)

Fazer algo múltiplas vezes:

especies = ["Ulva", "Gracilaria", "Sargassum"]

for especie in especies:
    print(f"Analisando: {especie}")

Resultado:

Analisando: Ulva
Analisando: Gracilaria
Analisando: Sargassum

🛠️ Funções (Reutilizar Código)

Função = bloco de código que pode ser usado várias vezes.

Exemplo 1: Função Simples

def saudar(nome):
    return f"Olá, {nome}! Bem-vindo à Oceanografia!"

# Usar a função
msg = saudar("Caetano")
print(msg)  # "Olá, Caetano! Bem-vindo à Oceanografia!"

Exemplo 2: Função para Análise

def calcular_media_temperatura(temperaturas):
    """Calcula a temperatura média"""
    total = sum(temperaturas)
    quantidade = len(temperaturas)
    return total / quantidade

# Dados de coleta
temps = [22.5, 23.1, 22.8, 23.4]
media = calcular_media_temperatura(temps)
print(f"Temperatura média: {media:.1f}°C")  # 22.95°C

Exemplo 3: Função com Múltiplas Operações

def analisar_amostra(especie, profundidade, temperatura):
    """Analisa uma amostra de coleta"""

    # Verificação
    if profundidade < 0:
        return "❌ Profundidade inválida"

    # Análise
    if temperatura > 25:
        condicao = "quente"
    else:
        condicao = "fria"

    # Resultado
    resultado = {
        "especie": especie,
        "profundidade": profundidade,
        "condicao": condicao,
        "valida": True
    }

    return resultado

# Usar função
amostra = analisar_amostra("Ulva lactuca", 5.2, 22.5)
print(amostra)
# {'especie': 'Ulva lactuca', 'profundidade': 5.2, 
#  'condicao': 'fria', 'valida': True}

📚 Variáveis (Contêineres de Informação)

Variáveis são "caixas" que armazenam informações.

# Criar variável
nome_pesquisador = "Caetano"
anos_experiencia = 5

# Modificar variável
anos_experiencia = 6

# Usar variável
print(f"{nome_pesquisador} tem {anos_experiencia} anos de experiência")
# Resultado: "Caetano tem 6 anos de experiência"

Nomes de Variáveis (Regras)

✅ Bom:

temperatura_media = 22.5
especie_coletada = "Ulva"
profundidade_m = 10

❌ Ruim:

a = 22.5              # muito genérico
temperatura média = 10  # não use espaço
9temperatura = 5      # não comece com número

🔗 Operadores (Operações Matemáticas)

Aritméticos

a = 10
b = 3

soma = a + b        # 13
subtracao = a - b   # 7
multiplicacao = a * b  # 30
divisao = a / b     # 3.333...
inteira = a // b    # 3 (sem decimais)
resto = a % b       # 1 (10 dividido por 3 deixa resto 1)
potencia = a ** b   # 1000 (10 ao cubo)

Comparação (resultado é True ou False)

10 > 5      # True
10 < 5      # False
10 == 10    # True (igual)
10 != 5     # True (diferente)
10 >= 10    # True (maior ou igual)

Lógicos

temperatura = 22.5
profundidade = 5

# AND (e)
if temperatura > 20 and profundidade < 10:
    print("✅ Condições ideais de coleta")

# OR (ou)
if temperatura < 15 or temperatura > 28:
    print("❌ Temperatura fora do ideal")

# NOT (não)
if not profundidade > 100:
    print("✅ Profundidade aceitável")

📁 Importar Bibliotecas (Usar Ferramentas)

Bibliotecas são códigos prontos que outras pessoas criaram.

O que é uma Biblioteca?

Imagine que programação é receita de bolo.
Uma biblioteca é um livro de receitas pronto!

Importar Bibliotecas

# Importar tudo
import numpy

# Usar função
dados = numpy.array([1, 2, 3, 4, 5])
print(numpy.mean(dados))  # 3.0

# Importar com apelido (mais prático)
import numpy as np
dados = np.array([1, 2, 3, 4, 5])
print(np.mean(dados))  # 3.0

# Importar função específica
from math import sqrt, pi
resultado = sqrt(16)  # 4.0

Bibliotecas Que Você Usará

# Análise de Dados
import pandas as pd      # Tabelas/DataFrames
import numpy as np       # Matrizes/Arrays

# Visualização
import matplotlib.pyplot as plt  # Gráficos
import folium                     # Mapas

# Geoespacial
import geopandas as gpd  # Dados com geografia
from shapely import Point, Polygon  # Geometrias

# Web
import requests  # Buscar dados na internet

💡 Pensamento Algorítmico

Um algoritmo é uma série de passos para resolver um problema.

Exemplo: Como Fazer Uma Coleta de Dados?

ALGORITMO: Coleta de Fitoplâncton

PASSO 1: Chegar no local de coleta
PASSO 2: Verificar temperatura e salinidade
PASSO 3: SE temperatura < 15 OU > 30
           ENTÃO: Não coletar
           SENÃO: Continuar
PASSO 4: Coletar amostra com garrafa
PASSO 5: Armazenar em recipiente estéril
PASSO 6: Anotar hora, coordenadas, profundidade
PASSO 7: Enviar para laboratório
PASSO 8: FIM

🎯 Exemplo Completo: Sistema de Análise

# Bibliotecas
import pandas as pd

# Dados de coleta
amostras = {
    'data': ['2025-01-01', '2025-01-02', '2025-01-03'],
    'especie': ['Ulva', 'Gracilaria', 'Sargassum'],
    'profundidade_m': [5.2, 7.8, 3.1],
    'temperatura_c': [22.5, 23.1, 22.8],
    'densidade_cells_ml': [150, 230, 180]
}

# Criar tabela
df = pd.DataFrame(amostras)

# Funções de análise
def validar_amostra(temp, prof):
    """Verifica se amostra é válida"""
    if 20 <= temp <= 25 and prof < 10:
        return "✅ Válida"
    else:
        return "❌ Inválida"

def densidade_media(densidade_list):
    """Calcula densidade média"""
    return sum(densidade_list) / len(densidade_list)

# Análises
print("=" * 60)
print("📊 RELATÓRIO DE ANÁLISE DE FITOPLÂNCTON")
print("=" * 60)

# Mostrar dados
print("\n📋 Dados Coletados:")
print(df.to_string())

# Validação
print("\n✓ Validação:")
for idx, row in df.iterrows():
    validacao = validar_amostra(row['temperatura_c'], row['profundidade_m'])
    print(f"  Amostra {idx+1}: {validacao}")

# Estatísticas
print("\n📈 Estatísticas:")
print(f"  Temperatura média: {df['temperatura_c'].mean():.1f}°C")
print(f"  Profundidade média: {df['profundidade_m'].mean():.1f}m")
print(f"  Densidade média: {densidade_media(df['densidade_cells_ml']):.0f} células/mL")
print(f"  Espécie mais frequente: {df['especie'].mode()[0]}")

print("\n" + "=" * 60)

Resultado:

============================================================
📊 RELATÓRIO DE ANÁLISE DE FITOPLÂNCTON
============================================================

📋 Dados Coletados:
        data       especie  profundidade_m  temperatura_c  densidade_cells_ml
0 2025-01-01          Ulva             5.2           22.5                 150
1 2025-01-02    Gracilaria             7.8           23.1                 230
2 2025-01-03     Sargassum             3.1           22.8                 180

✓ Validação:
  Amostra 1: ✅ Válida
  Amostra 2: ✅ Válida
  Amostra 3: ✅ Válida

📈 Estatísticas:
  Temperatura média: 22.8°C
  Profundidade média: 5.4m
  Densidade média: 187 células/mL
  Espécie mais frequente: Gracilaria

============================================================

🔄 Ciclo de Desenvolvimento

         ┌─────────────────────┐
         │  Problema Real      │
         │  (Ex: Mapear algas) │
         └──────────┬──────────┘
                    │
                    ↓
         ┌─────────────────────┐
         │  Planejar Solution  │
         │  (Algoritmo)        │
         └──────────┬──────────┘
                    │
                    ↓
         ┌─────────────────────┐
         │  Escrever Código    │
         │  (Implementação)    │
         └──────────┬──────────┘
                    │
                    ↓
         ┌─────────────────────┐
         │  Testar            │
         │  (Debug)           │
         └──────────┬──────────┘
                    │
              Funciona?
             /       \
           NÃO       SIM
            │         │
            └─────────┘
            ↓
         ┌─────────────────────┐
         │  Publicar           │
         │  (GitHub/web)       │
         └─────────────────────┘

📝 Checklist de Aprendizado

• [ ] Entendo o que é programação
• [ ] Conheço os tipos de dados básicos
• [ ] Entendo condições (if/else)
• [ ] Entendo repetições (loops)
• [ ] Consegui escrever uma função
• [ ] Importei uma biblioteca com sucesso
• [ ] Rodei um programa Python

Se marcou tudo, você está pronto para Python Essencial! 🎉

🎓 Conceitos-Chave para Lembrar

➡️ Próximo Passo

Agora que você entende os conceitos, vamos para:

👉 Módulo 1: PYTHON ESSENCIAL

Lá você aprenderá na prática: - Sintaxe Python - Estruturas de dados avançadas - Funções profissionais - Processamento de arquivos

🚀 Seu Progresso

0-FUNDAMENTOS
├── 01-Introducao ✅
├── 02-Configurar-Ambiente ✅
└── 03-Conceitos-Basicos ✅ (VOCÊ ESTÁ AQUI!)

Pronto para Python! 🐍

Parabéns por completar o módulo Fundamentos! 🎊

Você agora tem a base teórica. Vamos botar a mão na massa com Python? 🐍