# Variáveis e Tipos de Dados
idade = 30           # int
altura = 1.75        # float
nome = "Alice"       # str
eh_estudante = True  # bool
 
print(f"Nome: {nome}, Idade: {idade}, Altura: {altura}, Estudante: {eh_estudante}")
print(f"Tipo de idade: {type(idade)}")
print(f"Tipo de altura: {type(altura)}")

# Conversão de Tipos
numero_str = "123"
numero_int = int(numero_str)
print(f"String para Int: {numero_int} (Tipo: {type(numero_int)})")
 
preco_str = "99.99"
preco_float = float(preco_str)
print(f"String para Float: {preco_float} (Tipo: {type(preco_float)})")
 
valor_booleano = bool(0) # 0 é False, qualquer outro número é True
print(f"Int para Bool: {valor_booleano} (Tipo: {type(valor_booleano)})")

# Criação de Lista
dados_sensores = [23.5, 24.1, 23.9, 25.0, 24.8]
nomes_usuarios = ["Maria", "João", "Ana"]
 
# Acesso a elementos (indexação começa em 0)
print(f"Primeiro dado do sensor: {dados_sensores[0]}")
print(f"Último nome de usuário: {nomes_usuarios[-1]}")
 
# Fatiamento (Slicing)
print(f"Dados do sensor do segundo ao quarto: {dados_sensores[1:4]}")
 
# Modificação (mutabilidade)
dados_sensores.append(25.5) # Adiciona no final
dados_sensores[0] = 23.0    # Altera um elemento
print(f"Lista de sensores modificada: {dados_sensores}")
 
# Comprimento da lista
print(f"Número de leituras: {len(dados_sensores)}")

# Criação de Tupla
coordenadas = (10.5, 20.3)
cores_rgb = ("vermelho", "verde", "azul")
 
# Acesso a elementos
print(f"Coordenada X: {coordenadas[0]}")
 
# Tentativa de modificação (resulta em erro)
# coordenadas[0] = 11.0 # Isso geraria um TypeError
 
# Desempacotamento de tuplas
lat, lon = coordenadas
print(f"Latitude: {lat}, Longitude: {lon}")

# Criação de Dicionário
usuario_perfil = {
    "nome": "Carlos",
    "idade": 28,
    "cidade": "São Paulo",
    "interesses": ["ML", "Data Science", "Python"]
}
 
# Acesso a valores pela chave
print(f"Nome do usuário: {usuario_perfil['nome']}")
print(f"Interesses: {usuario_perfil.get('interesses')}") # Método .get() evita KeyError se a chave não existir
 
# Adicionar ou modificar pares chave-valor
usuario_perfil["profissao"] = "Engenheiro de Dados"
usuario_perfil["idade"] = 29
print(f"Perfil atualizado: {usuario_perfil}")
 
# Iterar sobre chaves, valores ou itens
print("\nChaves:")
for chave in usuario_perfil.keys():
    print(chave)
 
print("\nValores:")
for valor in usuario_perfil.values():
    print(valor)

# Criação de Conjunto
numeros_duplicados = [1, 2, 2, 3, 4, 4, 5]
numeros_unicos = set(numeros_duplicados)
print(f"Números únicos: {numeros_unicos}")
 
# Adicionar elemento
numeros_unicos.add(6)
print(f"Conjunto com novo elemento: {numeros_unicos}")
 
# Operações de conjunto
set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}
 
print(f"União: {set_a.union(set_b)}")         # {1, 2, 3, 4, 5, 6}
print(f"Interseção: {set_a.intersection(set_b)}") # {3, 4}
print(f"Diferença (A - B): {set_a.difference(set_b)}") # {1, 2}

# Condicionais
temperatura = 28.5
 
if temperatura > 30:
    print("Está muito quente! ☀️")
elif temperatura > 25:
    print("Temperatura agradável. 😎")
else:
    print("Está fresco. ❄️")
 
# Operadores lógicos: and, or, not
idade = 18
tem_carteira = True
 
if idade >= 18 and tem_carteira:
    print("Pode dirigir. 🚗")
else:
    print("Não pode dirigir. 🚶")

# Loop 'for'
lista_notas = [8.5, 7.0, 9.2, 6.8]
soma_notas = 0
 
print("Iterando sobre as notas:")
for nota in lista_notas:
    print(f"Nota: {nota}")
    soma_notas += nota
 
print(f"Soma total das notas: {soma_notas}")
 
# Loop 'for' com range (útil para iterar um número fixo de vezes)
print("\nContagem regressiva:")
for i in range(5, 0, -1): # Começa em 5, vai até 1 (exclusivo), decrementa de 1
    print(i)
 
# Loop 'while'
contador = 0
print("\nContando até 3:")
while contador < 3:
    print(f"Contador: {contador}")
    contador += 1 # Importante para evitar loop infinito!

# Definição de uma função simples
def saudar(nome):
    """Esta função saúda uma pessoa."""
    return f"Olá, {nome}! Bem-vindo(a) ao ML."
 
# Chamada da função
mensagem = saudar("Alice")
print(mensagem)
 
# Função com múltiplos parâmetros e valor padrão
def calcular_media(valores, casas_decimais=2):
    """Calcula a média de uma lista de valores."""
    if not valores: # Verifica se a lista não está vazia
        return 0.0
    soma = sum(valores)
    media = soma / len(valores)
    return round(media, casas_decimais)
 
notas = [7.5, 8.0, 9.0, 6.5]
media_alunos = calcular_media(notas)
print(f"Média das notas: {media_alunos}")
 
media_arredondada = calcular_media(notas, casas_decimais=1)
print(f"Média arredondada para 1 casa decimal: {media_arredondada}")
 
# Funções Lambda (funções anônimas de uma linha)
# Úteis para operações rápidas e passadas como argumentos para outras funções
multiplicar = lambda x, y: x * y
print(f"5 * 3 = {multiplicar(5, 3)}")
 
# Exemplo de uso com map()
numeros = [1, 2, 3, 4]
quadrados = list(map(lambda x: x**2, numeros))
print(f"Quadrados dos números: {quadrados}")

def processar_leituras_sensores(leituras_brutas):
    """
    Processa uma lista de leituras de sensores, filtrando valores inválidos,
    convertendo tipos e calculando estatísticas básicas.
 
    Args:
        leituras_brutas (list): Uma lista de leituras, podendo conter ints, floats ou strs.
 
    Returns:
        dict: Um dicionário contendo leituras válidas e estatísticas.
    """
    leituras_validas = []
    valores_invalidos = 0
 
    # 1. Iterar sobre as leituras (Loop 'for')
    for leitura in leituras_brutas:
        # 2. Verificar o tipo e converter (Condicionais 'if/elif/else', Conversão de Tipo)
        if isinstance(leitura, (int, float)):
            leituras_validas.append(leitura)
        elif isinstance(leitura, str):
            try:
                # Tentar converter string para float
                valor_convertido = float(leitura)
                leituras_validas.append(valor_convertido)
            except ValueError:
                # Se a conversão falhar, é um valor inválido
                valores_invalidos += 1
        else:
            valores_invalidos += 1
 
    # 3. Calcular estatísticas (Variáveis, Funções Built-in)
    if leituras_validas:
        media = sum(leituras_validas) / len(leituras_validas)
        max_valor = max(leituras_validas)
        min_valor = min(leituras_validas)
    else:
        media = 0.0
        max_valor = None
        min_valor = None
 
    # 4. Retornar resultados em um Dicionário
    resultado = {
        "leituras_processadas": leituras_validas,
        "media": round(media, 2),
        "maximo": max_valor,
        "minimo": min_valor,
        "total_invalidos": valores_invalidos
    }
    return resultado
 
# Dados de exemplo
dados_sensores_brutos = [22.5, "23.1", 24.0, "erro", 21.9, None, 25.5, "22.8"]
 
# Processar os dados usando a função
relatorio = processar_leituras_sensores(dados_sensores_brutos)
 
# Imprimir o relatório (Dicionário)
print("--- Relatório de Leituras de Sensores ---")
for chave, valor in relatorio.items():
    print(f"{chave.replace('_', ' ').title()}: {valor}")
 
print(f"\nLeituras processadas para análise: {relatorio['leituras_processadas']}")