1 Python Essencial — Módulo completo

# Variáveis e tipos
nome = "Maria"  # string
idade = 25      # int
altura = 1.65   # float
ativo = True    # bool

# Lista (mutável)
frutas = ["maçã", "banana", "uva"]
frutas.append("laranja")

# Tupla (imutável)
coordenadas = (10, 20)

# Dicionário
pessoa = {
    "nome": "João",
    "idade": 30,
    "cidade": "Florianópolis"
}

# Função
def calcular_area(largura, altura):
    """Calcula área de retângulo"""
    return largura * altura

# Condicional
if idade >= 18:
    print("Maior de idade")
else:
    print("Menor de idade")

# Loop for
for fruta in frutas:
    print(fruta)

# Loop while
contador = 0
while contador < 5:
    print(contador)
    contador += 1

# Comprehension
quadrados = [x**2 for x in range(10)]

# Try/except
try:
    resultado = 10 / 0
except ZeroDivisionError:
    print("Divisão por zero!")

print("🎉 Olá, Mundo!")

python hello.py

🎉 Olá, Mundo!

# Isto é um comentário de linha única
# Python ignora tudo depois de #

print("Isto executa")  # Comentário depois do código

# Comentário de múltiplas linhas
# Você pode escrever quantas linhas quiser
# Python ignora tudo

"""
Isto é um docstring (comentário de documentação)
Usado para descrever funções e módulos
Pode ter múltiplas linhas
"""

# ❌ Ruim - explica óbvio
x = x + 1  # Adiciona 1 a x

# ✅ Bom - explica o contexto
profundidade_final = profundidade_inicial + incremento_coleta  # Soma profundidade de coleta

# Texto simples
print("Olá, Oceanógrafo!")

# Múltiplos valores
print("Temperatura:", 22.5)

# Vários argumentos separados por vírgula
print("Data", "Espécie", "Profundidade")

# Sem quebra de linha
print("Python", end=" ")
print("Oceanografia")  # Resultado: "Python Oceanografia"

# Com separador customizado
print("Ulva", "Gracilaria", "Sargassum", sep=" | ")
# Resultado: Ulva | Gracilaria | Sargassum

# Solicitar nome
nome = input("Qual seu nome? ")
print(f"Bem-vindo, {nome}!")

# Solicitar número
# ⚠️ IMPORTANTE: input() sempre retorna TEXTO!
idade_texto = input("Qual sua idade? ")
idade = int(idade_texto)  # Converter para número

# Forma abreviada
idade = int(input("Qual sua idade? "))

# Sistema de cadastro de amostra
print("=" * 50)
print("📝 CADASTRO DE AMOSTRA DE COLETA")
print("=" * 50)

especie = input("Espécie coletada: ")
profundidade = float(input("Profundidade (m): "))
temperatura = float(input("Temperatura (°C): "))

print("\n✅ Amostra cadastrada:")
print(f"   Espécie: {especie}")
print(f"   Profundidade: {profundidade}m")
print(f"   Temperatura: {temperatura}°C")

python coleta_dados.py

==================================================
📝 CADASTRO DE AMOSTRA DE COLETA
==================================================
Espécie coletada: Ulva lactuca
Profundidade (m): 5.2
Temperatura (°C): 22.5

✅ Amostra cadastrada:
   Espécie: Ulva lactuca
   Profundidade: 5.2m
   Temperatura: 22.5°C

# Método 1: Usar + (mais antigo)
nome = "Caetano"
sobrenome = "Ronan"
completo = nome + " " + sobrenome
print(completo)  # Caetano Ronan

# Método 2: f-string (RECOMENDADO - Python 3.6+)
especie = "Ulva lactuca"
profundidade = 5.2
msg = f"Amostra de {especie} a {profundidade}m"
print(msg)  # Amostra de Ulva lactuca a 5.2m

# Dentro de f-string, você pode usar expressões!
temperatura = 22.5
print(f"Temperatura: {temperatura:.1f}°C")  # .1f = 1 casa decimal
print(f"Temperatura + 5: {temperatura + 5}°C")

texto = "Oceanografia"

# Tamanho
print(len(texto))  # 12

# Maiúsculas
print(texto.upper())  # OCEANOGRAFIA

# Minúsculas
print(texto.lower())  # oceanografia

# Primeira letra maiúscula
print(texto.capitalize())  # Oceanografia

# Substituir texto
print(texto.replace("Oceano", "Bio"))  # Biorafia

# Dividir em partes
frase = "Ulva,Gracilaria,Sargassum"
especies = frase.split(",")
print(especies)  # ['Ulva', 'Gracilaria', 'Sargassum']

# Verificar se contém
if "Ulva" in frase:
    print("✅ Ulva encontrada!")

a = 10
b = 3

print(a + b)    # 13
print(a - b)    # 7
print(a * b)    # 30
print(a / b)    # 3.333... (divisão com decimal)
print(a // b)   # 3 (divisão inteira)
print(a % b)    # 1 (resto da divisão)
print(a ** b)   # 1000 (10 elevado a 3)

# Operações com atribuição
numero = 5
numero += 3  # numero = numero + 3 → 8
numero -= 2  # numero = numero - 2 → 6
numero *= 2  # numero = numero * 2 → 12
numero //= 3 # numero = numero // 3 → 4

temperatura = 22.5
profundidade = 5.0
salinidade = 35.123456

# Arredondamento
print(round(salinidade, 2))  # 35.12 (2 casas decimais)
print(round(salinidade, 1))  # 35.1 (1 casa decimal)

# Função abs (valor absoluto)
print(abs(-5.2))  # 5.2

# Funções matemáticas
import math
print(math.sqrt(16))  # 4.0 (raiz quadrada)
print(math.pi)        # 3.14159...
print(math.ceil(5.2))  # 6 (arredonda para cima)
print(math.floor(5.8)) # 5 (arredonda para baixo)

# Valores booleanos
verdade = True
falsidade = False

# Comparações retornam booleanos
print(5 > 3)      # True
print(5 < 3)      # False
print(5 == 5)     # True (igual)
print(5 != 3)     # True (diferente)
print(5 >= 5)     # True (maior ou igual)

# Operadores lógicos
print(True and True)    # True
print(True and False)   # False
print(True or False)    # True
print(not True)         # False

# Exemplos práticos
temperatura = 22.5
profundidade = 5.2

# Verificar se coleta foi válida
valida = (temperatura > 20) and (profundidade < 10)
print(f"Coleta válida: {valida}")  # True

# String para Número
texto_numero = "123"
numero = int(texto_numero)
print(tipo)  # <class 'int'>

# Número para String
numero = 42
texto = str(numero)
print(texto)  # "42"

# String para Decimal
texto_decimal = "3.14"
decimal = float(texto_decimal)
print(decimal)  # 3.14

# Número para Boolean
print(bool(0))     # False (0 é falso)
print(bool(1))     # True (número != 0 é verdadeiro)
print(bool(""))    # False (string vazia é falsa)
print(bool("Oi"))  # True (string não vazia é verdadeira)

print(type(5))              # <class 'int'>
print(type(5.0))            # <class 'float'>
print(type("Olá"))          # <class 'str'>
print(type(True))           # <class 'bool'>
print(type([1, 2, 3]))      # <class 'list'>

# Usar em condição
valor = "123"
if type(valor) == str:
    print("É uma string!")

print("🌊 SISTEMA DE ANÁLISE DE COLETA")
print("-" * 50)

# Receber dados
especie = input("Espécie: ")
profundidade = float(input("Profundidade (m): "))
temperatura = float(input("Temperatura (°C): "))
salinidade = float(input("Salinidade (PSU): "))

# Validações
print("\n📊 ANÁLISE:")

# Verificar profundidade
if profundidade < 5:
    profundidade_status = "Rasa"
elif profundidade < 20:
    profundidade_status = "Intermediária"
else:
    profundidade_status = "Profunda"
print(f"Profundidade: {profundidade}m ({profundidade_status})")

# Verificar temperatura
if 20 <= temperatura <= 25:
    temp_status = "✅ Ideal"
else:
    temp_status = "⚠️ Fora do padrão"
print(f"Temperatura: {temperatura}°C {temp_status}")

# Verificar salinidade
salinidade_arredondada = round(salinidade, 1)
print(f"Salinidade: {salinidade_arredondada} PSU")

# Resumo
valida = (20 <= temperatura <= 25) and (profundidade < 50)
status_final = "✅ VÁLIDA" if valida else "❌ INVÁLIDA"
print(f"\nStatus da coleta: {status_final}")

python analise_coleta.py

# ✅ BOM - Descritivo, em inglês ou português claro
temperatura_media = 22.5
profundidade_coleta_m = 5.2
especie_coletada = "Ulva lactuca"
numero_amostras = 10

# ❌ RUIM - Genérico ou confuso
t = 22.5
x = 5.2
s = "Ulva lactuca"
n = 10

# ✅ BOM - Constantes em MAIÚSCULA
PI = 3.14159
PROFUNDIDADE_MAXIMA = 100
TEMPERATURA_IDEAL_MINIMA = 20
TEMPERATURA_IDEAL_MAXIMA = 25

# ❌ EVITAR
meu_valor_muito_longo_que_ninguem_entende = 42
_variavel = 10  # Convenção: começa com _ = privada

# Variável global
mensagem_global = "Oceanografia UFSC"

if True:
    # Variável local
    mensagem_local = "LAFIC"
    print(mensagem_global)  # ✅ Funciona
    print(mensagem_local)   # ✅ Funciona

print(mensagem_global)  # ✅ Funciona
print(mensagem_local)   # ❌ ERRO - não existe fora do bloco

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Calculadora Oceanográfica
Calcula propriedades de água marinha
"""

print("=" * 60)
print("🌊 CALCULADORA OCEANOGRÁFICA")
print("=" * 60)

# Constantes
SALINIDADE_PADRAO = 35.0
DENSIDADE_AGUA_DOCE = 1.0
DENSIDADE_AGUA_SALGADA_COEF = 0.8

# Entrada de dados
print("\n📥 Digite os parâmetros:")
profundidade = float(input("Profundidade (m): "))
temperatura = float(input("Temperatura (°C): "))
salinidade = float(input("Salinidade (PSU): "))

# Cálculos
print("\n📊 RESULTADOS:\n")

# Densidade aproximada
densidade = 1000 + (salinidade - SALINIDADE_PADRAO) * 0.78
print(f"Densidade da água: {densidade:.2f} kg/m³")

# Pressão aproximada (1 atm por 10m)
pressao_atm = 1 + (profundidade / 10)
print(f"Pressão: {pressao_atm:.2f} atm")

# Luz solar (50% em ~5m, ~1% em ~30m)
penetracao_luz = 100 * (0.7 ** (profundidade / 10))
print(f"Penetração de luz: {penetracao_luz:.1f}%")

# Status da coleta
print("\n✓ STATUS DA COLETA:")
if 20 <= temperatura <= 28:
    print("✅ Temperatura adequada")
else:
    print("⚠️ Temperatura fora do ideal")

if 34 <= salinidade <= 36:
    print("✅ Salinidade adequada")
else:
    print("⚠️ Salinidade fora do ideal")

if profundidade < 50:
    print("✅ Profundidade acessível")
else:
    print("⚠️ Profundidade muito grande")

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

# Lista vazia
lista_vazia = []

# Lista com valores
especies = ["Ulva", "Gracilaria", "Sargassum"]
temperaturas = [22.5, 23.1, 22.8, 23.4, 22.9]
dados_mistos = [1, "texto", 3.14, True, [1, 2, 3]]

# Usando list()
numeros = list(range(1, 6))  # [1, 2, 3, 4, 5]

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

# Índices começam em 0!
print(especies[0])   # "Ulva"
print(especies[1])   # "Gracilaria"
print(especies[2])   # "Sargassum"

# Índices negativos (do final para trás)
print(especies[-1])  # "Sargassum" (último)
print(especies[-2])  # "Gracilaria" (penúltimo)

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

# Alterar elemento
especies[0] = "Ulva lactuca"

# Adicionar um elemento no final
especies.append("Laminaria")
print(especies)  # ["Ulva lactuca", "Gracilaria", "Sargassum", "Laminaria"]

# Inserir em posição específica
especies.insert(1, "Chondracanthus")
print(especies)  # ["Ulva lactuca", "Chondracanthus", ...]

# Remover elemento (por valor)
especies.remove("Sargassum")

# Remover elemento (por índice)
removida = especies.pop(0)  # Remove e retorna primeiro

# Remover tudo
especies.clear()

temperaturas = [22.5, 23.1, 22.8, 23.4, 22.9]

# Tamanho
print(len(temperaturas))  # 5

# Soma
print(sum(temperaturas))  # 114.7

# Máximo e mínimo
print(max(temperaturas))  # 23.4
print(min(temperaturas))  # 22.5

# Ordenar
ordenado = sorted(temperaturas)
print(ordenado)  # [22.5, 22.8, 22.9, 23.1, 23.4]

# Reverso
reverso = list(reversed(temperaturas))
print(reverso)  # [22.9, 23.4, 22.8, 23.1, 22.5]

# Verificar se contém
if 22.5 in temperaturas:
    print("✅ Encontrada")

# Contar ocorrências
amostras = ["Ulva", "Gracilaria", "Ulva", "Ulva", "Sargassum"]
print(amostras.count("Ulva"))  # 3

# Encontrar índice
print(amostras.index("Gracilaria"))  # 1

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

# [início:fim:passo] - fim é EXCLUSIVO!
print(especies[0:2])      # ["Ulva", "Gracilaria"]
print(especies[1:4])      # ["Gracilaria", "Sargassum", "Laminaria"]
print(especies[:3])       # ["Ulva", "Gracilaria", "Sargassum"] (começa do início)
print(especies[2:])       # ["Sargassum", "Laminaria", "Chondracanthus"] (até o fim)
print(especies[::2])      # ["Ulva", "Sargassum", "Chondracanthus"] (cada 2)
print(especies[::-1])     # Reverso! ["Chondracanthus", "Laminaria", ...]

lista1 = [1, 2, 3]
lista2 = [4, 5, 6]

# Juntar
combinada = lista1 + lista2
print(combinada)  # [1, 2, 3, 4, 5, 6]

# Repetir
repetida = [1, 2] * 3
print(repetida)  # [1, 2, 1, 2, 1, 2]

# Dividir (string para lista)
texto = "Ulva,Gracilaria,Sargassum"
especies = texto.split(",")
print(especies)  # ["Ulva", "Gracilaria", "Sargassum"]

# Juntar (lista para string)
resultado = " | ".join(especies)
print(resultado)  # "Ulva | Gracilaria | Sargassum"

# Dicionário vazio
vazio = {}

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

# Usando dict()
dados = dict(nome="Caetano", profissao="Oceanógrafo")

amostra = {
    "especie": "Ulva lactuca",
    "profundidade": 5.2,
    "temperatura": 22.5
}

# Acessar por chave
print(amostra["especie"])      # "Ulva lactuca"
print(amostra["profundidade"]) # 5.2

# Usando .get() (mais seguro)
print(amostra.get("especie"))        # "Ulva lactuca"
print(amostra.get("salario", "N/A")) # "N/A" (não existe)

amostra = {"especie": "Ulva", "profundidade": 5.2}

# Adicionar chave
amostra["temperatura"] = 22.5

# Modificar existente
amostra["profundidade"] = 6.0

# Remover chave
del amostra["temperatura"]

# Remover e retornar
valor = amostra.pop("profundidade")  # Remove e retorna 6.0

# Limpar tudo
amostra.clear()

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

# Tamanho
print(len(amostra))  # 4

# Chaves
print(amostra.keys())  # dict_keys(['especie', 'profundidade', ...])

# Valores
print(amostra.values())  # dict_values(['Ulva', 5.2, 22.5, True])

# Pares chave-valor
print(amostra.items())  # dict_items([('especie', 'Ulva'), ...])

# Verificar se chave existe
if "especie" in amostra:
    print("✅ Existe")

# Atualizar múltiplas chaves
amostra.update({"profundidade": 7.0, "salinidade": 35.0})

# Criar vários registros
amostras = [
    {"id": 1, "especie": "Ulva", "prof_m": 5.2, "temp_c": 22.5},
    {"id": 2, "especie": "Gracilaria", "prof_m": 7.8, "temp_c": 23.1},
    {"id": 3, "especie": "Sargassum", "prof_m": 3.1, "temp_c": 22.8}
]

# Acessar
print(amostras[0]["especie"])  # "Ulva"
print(amostras[1]["temp_c"])   # 23.1

# Iterar
for amostra in amostras:
    print(f"ID {amostra['id']}: {amostra['especie']} a {amostra['prof_m']}m")

# Tupla (com parênteses)
coordenadas = (27.5, -48.5)  # latitude, longitude

# Acessar
print(coordenadas[0])  # 27.5
print(coordenadas[1])  # -48.5

# Tuplas são imutáveis
coordenadas[0] = 28.0  # ❌ ERRO!

# Mas podem ser reatribuídas
coordenadas = (28.0, -48.5)  # ✅ OK

# Desempacotamento
lat, lon = coordenadas
print(f"Latitude: {lat}, Longitude: {lon}")

# Múltiplos retornos de função
def get_localizacao():
    return (27.5, -48.5, 15)  # lat, lon, profundidade

lat, lon, prof = get_localizacao()

# Criar conjunto
especies_unicas = {"Ulva", "Gracilaria", "Sargassum", "Ulva"}
print(especies_unicas)  # {'Ulva', 'Gracilaria', 'Sargassum'} - sem duplicata!

# Operações
especies_unicas.add("Laminaria")
especies_unicas.remove("Ulva")

# Interseção (elementos em comum)
grupo1 = {"Ulva", "Gracilaria", "Sargassum"}
grupo2 = {"Ulva", "Laminaria", "Codium"}
comuns = grupo1 & grupo2
print(comuns)  # {'Ulva'}

# União (tudo)
todos = grupo1 | grupo2
print(todos)  # {'Ulva', 'Gracilaria', 'Sargassum', 'Laminaria', 'Codium'}

# Diferença
so_em_grupo1 = grupo1 - grupo2

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

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

# Iterar com índice
for i, especie in enumerate(especies):
    print(f"{i}: {especie}")  # 0: Ulva, 1: Gracilaria, 2: Sargassum

# Iterar com range
for i in range(len(especies)):
    print(f"{i}: {especies[i]}")

amostra = {"especie": "Ulva", "prof_m": 5.2, "temp_c": 22.5}

# Iterar chaves
for chave in amostra:
    print(chave)

# Iterar valores
for valor in amostra.values():
    print(valor)

# Iterar pares
for chave, valor in amostra.items():
    print(f"{chave}: {valor}")

# Contar até 5
contador = 1
while contador <= 5:
    print(f"Contagem: {contador}")
    contador += 1

# Coletar dados até digitar "sair"
temperaturas = []
while True:
    temp = input("Digite temperatura (ou 'sair'): ")
    if temp.lower() == "sair":
        break
    temperaturas.append(float(temp))

print(f"Temperaturas coletadas: {temperaturas}")

# Forma tradicional
quadrados = []
for i in range(1, 6):
    quadrados.append(i ** 2)
print(quadrados)  # [1, 4, 9, 16, 25]

# Compreensão de lista (mais Pythônica)
quadrados = [i ** 2 for i in range(1, 6)]
print(quadrados)  # [1, 4, 9, 16, 25]

# Com condição
pares = [i for i in range(1, 11) if i % 2 == 0]
print(pares)  # [2, 4, 6, 8, 10]

# Exemplo oceanográfico
temperaturas_raw = [22.5, 23.1, 22.8, 23.4, 22.9]
# Arredondar todas para 1 casa decimal
temperaturas_limpas = [round(t, 1) for t in temperaturas_raw]
print(temperaturas_limpas)  # [22.5, 23.1, 22.8, 23.4, 22.9]

# Com transformação
especias_maiusculas = [sp.upper() for sp in ["Ulva", "Gracilaria"]]
print(especias_maiusculas)  # ['ULVA', 'GRACILARIA']

"""
Sistema de análise de amostras de ficologia
"""

# Banco de dados de amostras
amostras = [
    {"id": 1, "especie": "Ulva lactuca", "prof_m": 5.2, "temp_c": 22.5, "sal_psu": 35.0},
    {"id": 2, "especie": "Gracilaria", "prof_m": 7.8, "temp_c": 23.1, "sal_psu": 34.8},
    {"id": 3, "especie": "Sargassum", "prof_m": 3.1, "temp_c": 22.8, "sal_psu": 35.1},
    {"id": 4, "especie": "Ulva lactuca", "prof_m": 6.5, "temp_c": 23.4, "sal_psu": 35.0},
]

print("=" * 60)
print("📊 ANÁLISE DE AMOSTRAS - LAFIC")
print("=" * 60)

# 1. Listar todas as amostras
print("\n📋 AMOSTRAS COLETADAS:")
for amostra in amostras:
    print(f"  #{amostra['id']}: {amostra['especie']} "
          f"({amostra['prof_m']}m, {amostra['temp_c']}°C)")

# 2. Encontrar espécie mais frequente
especies = [a["especie"] for a in amostras]
especie_freq = max(set(especies), key=especies.count)
print(f"\n🌿 Espécie mais frequente: {especie_freq}")

# 3. Média de profundidade
profundidades = [a["prof_m"] for a in amostras]
prof_media = sum(profundidades) / len(profundidades)
print(f"📏 Profundidade média: {prof_media:.1f}m")

# 4. Temperatura extrema
temp_minima = min(amostras, key=lambda x: x["temp_c"])
temp_maxima = max(amostras, key=lambda x: x["temp_c"])
print(f"🌡️ Temperatura: {temp_minima['temp_c']}°C (min) a {temp_maxima['temp_c']}°C (max)")

# 5. Filtrar amostras válidas
validas = [a for a in amostras if 20 <= a["temp_c"] <= 25]
print(f"\n✅ Amostras válidas: {len(validas)}/{len(amostras)}")

# 6. Relatório final
print("\n" + "=" * 60)
print("✓ Análise concluída com sucesso!")

python analise_amostras.py

Sem funções: Copiar e colar o mesmo código 100 vezes
Com funções: Escrever uma vez, usar 100 vezes

def nome_funcao():
    """Descrição da função (docstring)"""
    # código aqui
    pass

# Chamar função
nome_funcao()

def saudar():
    """Sauda o usuário"""
    print("Olá, bem-vindo ao LAFIC!")

# Chamar
saudar()  # Printa: "Olá, bem-vindo ao LAFIC!"

def saudar(nome):
    """Sauda uma pessoa específica"""
    print(f"Olá, {nome}!")

# Chamar com argumento
saudar("Caetano")      # Printa: "Olá, Caetano!"
saudar("Mariana")      # Printa: "Olá, Mariana!"

# Múltiplos parâmetros
def calcular_imc(peso, altura):
    """Calcula IMC"""
    imc = peso / (altura ** 2)
    return imc

resultado = calcular_imc(70, 1.75)
print(f"IMC: {resultado:.1f}")

def saudar(nome, idioma="português"):
    """Sauda em um idioma"""
    if idioma == "português":
        print(f"Olá, {nome}!")
    elif idioma == "inglês":
        print(f"Hello, {nome}!")

# Chamar
saudar("Caetano")                    # Usa padrão português
saudar("Caetano", idioma="inglês")   # Especifica inglês

def celsius_para_fahrenheit(celsius):
    """Converte Celsius para Fahrenheit"""
    fahrenheit = (celsius * 9/5) + 32
    return fahrenheit

# Usar retorno
temp_f = celsius_para_fahrenheit(22.5)
print(f"22.5°C = {temp_f:.1f}°F")  # 72.5°F

# Sem salvar
print(celsius_para_fahrenheit(25))  # 77.0

def calcular_estatisticas(numeros):
    """Calcula média, mín e máx"""
    media = sum(numeros) / len(numeros)
    minimo = min(numeros)
    maximo = max(numeros)
    return media, minimo, maximo

# Desempacotar retorno
temps = [22.5, 23.1, 22.8, 23.4]
media, minima, maxima = calcular_estatisticas(temps)
print(f"Média: {media:.1f}, Min: {minima}, Max: {maxima}")
# Média: 23.0, Min: 22.5, Max: 23.4

def analisar_amostra(especie, prof_m, temp_c):
    """Analisa uma amostra e retorna resultado"""

    valida = 20 <= temp_c <= 25 and prof_m < 10

    resultado = {
        "especie": especie,
        "profundidade_m": prof_m,
        "temperatura_c": temp_c,
        "valida": valida,
        "status": "✅ VÁLIDA" if valida else "❌ INVÁLIDA"
    }

    return resultado

# Usar
analise = analisar_amostra("Ulva lactuca", 5.2, 22.5)
print(analise["status"])  # ✅ VÁLIDA

def processar_temperatura(celsius):
    """
    Converte temperatura de Celsius para Fahrenheit.

    Args:
        celsius (float): Temperatura em Celsius

    Returns:
        float: Temperatura em Fahrenheit

    Example:
        >>> processar_temperatura(0)
        32.0
        >>> processar_temperatura(100)
        212.0
    """
    return (celsius * 9/5) + 32

# Ver documentação
help(processar_temperatura)
# ou
print(processar_temperatura.__doc__)

def validar_amostra(especie, profundidade, temperatura, salinidade):
    """
    Valida uma amostra de coleta.

    Returns:
        dict: Resultado da validação com status e mensagens
    """

    erros = []
    avisos = []

    # Validação de espécie
    especies_validas = ["Ulva", "Gracilaria", "Sargassum", "Laminaria"]
    if especie not in especies_validas:
        erros.append(f"Espécie '{especie}' não reconhecida")

    # Validação de profundidade
    if profundidade < 0:
        erros.append("Profundidade não pode ser negativa")
    elif profundidade > 100:
        avisos.append("Profundidade muito grande (>100m)")

    # Validação de temperatura
    if not (15 <= temperatura <= 30):
        erros.append(f"Temperatura {temperatura}°C fora do intervalo (15-30°C)")
    if temperatura < 20 or temperatura > 25:
        avisos.append("Temperatura não ideal (ideal: 20-25°C)")

    # Validação de salinidade
    if not (30 <= salinidade <= 40):
        erros.append(f"Salinidade {salinidade} PSU fora do intervalo (30-40)")

    # Resultado
    valida = len(erros) == 0

    return {
        "valida": valida,
        "status": "✅ VÁLIDA" if valida else "❌ INVÁLIDA",
        "erros": erros,
        "avisos": avisos
    }

# Teste
resultado = validar_amostra("Ulva", 5.2, 22.5, 35.0)
print(resultado["status"])      # ✅ VÁLIDA
print(resultado["erros"])       # []

resultado2 = validar_amostra("Alga desconhecida", -5, 35, 50)
print(resultado2["status"])     # ❌ INVÁLIDA
print(resultado2["erros"])      # Lista de erros

# Variável global
mensagem_global = "LAFIC"

def mostrar_mensagem():
    # Pode acessar global
    print(mensagem_global)

    # Variável local
    mensagem_local = "Oceanografia"
    print(mensagem_local)

mostrar_mensagem()
# Printa:
# LAFIC
# Oceanografia

print(mensagem_global)  # ✅ Funciona
print(mensagem_local)   # ❌ ERRO - não existe fora da função

contador = 0

def incrementar():
    global contador  # Autorizar modificação
    contador += 1

incrementar()
print(contador)  # 1

"""
Módulo com funções oceanográficas
"""

def celsius_para_fahrenheit(celsius):
    """Converte Celsius para Fahrenheit"""
    return (celsius * 9/5) + 32

def calcular_densidade_agua(salinidade, temperatura):
    """Calcula densidade aproximada da água"""
    # Fórmula simplificada
    densidade = 1000 + (salinidade - 35) * 0.78 - (temperatura - 15) * 0.2
    return densidade

def validar_coleta(temperatura, profundidade):
    """Verifica se coleta foi válida"""
    return 20 <= temperatura <= 25 and profundidade < 50

# Importar tudo
import oceanografia

# Usar funções
temp_f = oceanografia.celsius_para_fahrenheit(22.5)
print(f"22.5°C = {temp_f:.1f}°F")

# Importar funções específicas
from oceanografia import celsius_para_fahrenheit, calcular_densidade_agua

temp_f = celsius_para_fahrenheit(25)
densidade = calcular_densidade_agua(35.0, 22.5)
print(f"Densidade: {densidade:.2f} kg/m³")

# Importar com apelido
from oceanografia import validar_coleta as validar

if validar(22.5, 5.2):
    print("✅ Coleta válida!")

import math

print(math.pi)              # 3.14159...
print(math.sqrt(16))        # 4.0
print(math.ceil(5.2))       # 6 (arredonda para cima)
print(math.floor(5.8))      # 5 (arredonda para baixo)
print(math.sin(math.pi/2))  # 1.0

from datetime import datetime, timedelta

agora = datetime.now()
print(agora)  # 2025-01-06 14:30:45.123456

# Formatar
print(agora.strftime("%d/%m/%Y"))  # 06/01/2025

# Adicionar dias
amanha = agora + timedelta(days=1)
print(amanha)

import random

# Número aleatório
print(random.random())  # 0.123456... (0 a 1)

# Inteiro aleatório
print(random.randint(1, 10))  # Número de 1 a 10

# Escolher da lista
especies = ["Ulva", "Gracilaria", "Sargassum"]
escolhida = random.choice(especies)
print(escolhida)  # Aleatória

# Embaralhar
random.shuffle(especies)
print(especies)  # Embaralhada

"""
Processador de dados de coleta oceanográfica
"""

def carregar_dados():
    """Simula carregamento de dados"""
    return [
        {"especie": "Ulva", "prof_m": 5.2, "temp_c": 22.5, "sal_psu": 35.0},
        {"especie": "Gracilaria", "prof_m": 7.8, "temp_c": 23.1, "sal_psu": 34.8},
        {"especie": "Sargassum", "prof_m": 3.1, "temp_c": 22.8, "sal_psu": 35.1},
    ]

def validar_dados(amostras):
    """Valida todas as amostras"""
    validas = 0
    invalidas = 0

    for amostra in amostras:
        if 20 <= amostra["temp_c"] <= 25 and amostra["prof_m"] < 10:
            validas += 1
        else:
            invalidas += 1

    return validas, invalidas

def calcular_medias(amostras):
    """Calcula médias dos parâmetros"""
    temps = [a["temp_c"] for a in amostras]
    profs = [a["prof_m"] for a in amostras]
    sals = [a["sal_psu"] for a in amostras]

    return {
        "temp_media_c": sum(temps) / len(temps),
        "prof_media_m": sum(profs) / len(profs),
        "sal_media_psu": sum(sals) / len(sals)
    }

def gerar_relatorio(amostras):
    """Gera relatório completo"""
    print("=" * 60)
    print("🌊 RELATÓRIO DE COLETA - LAFIC")
    print("=" * 60)

    # Total de amostras
    print(f"\n📊 Total de amostras: {len(amostras)}")

    # Validação
    validas, invalidas = validar_dados(amostras)
    print(f"✅ Válidas: {validas}")
    print(f"❌ Inválidas: {invalidas}")

    # Médias
    medias = calcular_medias(amostras)
    print(f"\n📈 Médias:")
    print(f"   Temperatura: {medias['temp_media_c']:.1f}°C")
    print(f"   Profundidade: {medias['prof_media_m']:.1f}m")
    print(f"   Salinidade: {medias['sal_media_psu']:.2f} PSU")

    # Espécies
    especies = [a["especie"] for a in amostras]
    print(f"\n🌿 Espécies coletadas: {', '.join(set(especies))}")

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

# Executar
if __name__ == "__main__":
    dados = carregar_dados()
    gerar_relatorio(dados)

python processador_dados.py