import sys

print("versão:", sys.version.split()[0])
print("executável:", sys.executable.split("/")[-1])
print("primeiros caminhos de busca:")
for caminho in sys.path[:4]:
    print("  ", caminho or "(pasta atual)")

import math                      # nome do modulo como prefixo
import statistics as stat        # apelido
from math import sqrt, pi        # apenas o que sera usado
from math import log10 as db     # apelido do que foi importado

print(math.cos(0), stat.mean([1, 2, 3]))
print(sqrt(16), round(pi, 4), db(1000))

# Evite "from math import *": sobrescreve nomes sem avisar.

import os

os.makedirs("laboratorio", exist_ok=True)

with open("laboratorio/__init__.py", "w", encoding="utf-8") as f:
    f.write("VERSAO = '1.0'\n")

with open("laboratorio/rf.py", "w", encoding="utf-8") as f:
    f.write("import math\n\n"
            "def watts_para_dbm(p):\n"
            "    return 10 * math.log10(p * 1000)\n\n"
            "def dbm_para_watts(d):\n"
            "    return 10 ** (d / 10) / 1000\n")

from laboratorio import rf, VERSAO

print("pacote versão", VERSAO)
print(rf.watts_para_dbm(0.1), "dBm")
print(round(rf.dbm_para_watts(30), 3), "W")

# 1. criar o ambiente dentro da pasta do projeto
python3 -m venv .venv

# 2. ativar
source .venv/bin/activate        # Linux e macOS
.venv\Scripts\activate           # Windows

# 3. instalar o basico deste manual
pip install numpy matplotlib pandas

# 4. congelar e reproduzir
pip freeze > requisitos.txt
pip install -r requisitos.txt

# 5. sair do ambiente
deactivate

from importlib.metadata import version, PackageNotFoundError

for pacote in ["numpy", "matplotlib", "pandas", "pyserial"]:
    try:
        print(f"{pacote:<12} {version(pacote)}")
    except PackageNotFoundError:
        print(f"{pacote:<12} não instalado")

python3 -m venv .venv          # cria ambiente
python3 -m pip install numpy   # forma segura de chamar o pip
python3 -m http.server 8000    # servidor de arquivos na pasta
python3 -m json.tool dados.json  # formata um JSON
python3 -m timeit "sum(range(1000))"

import math

print("pi:", math.pi)
print("e:", math.e)
print("raiz de 2:", math.sqrt(2))
print("hipotenusa 3,4:", math.hypot(3, 4))
print("exponencial:", math.exp(1))
print("valor absoluto:", math.fabs(-7.5))
print("fatorial de 6:", math.factorial(6))
print("mdc e mmc:", math.gcd(24, 36), math.lcm(4, 6))

import math

valores = [3.2, 3.7, -3.2, -3.7]

print(f"{'valor':>6}{'floor':>7}{'ceil':>6}{'trunc':>7}{'round':>7}")
for v in valores:
    print(f"{v:>6}{math.floor(v):>7}{math.ceil(v):>6}"
          f"{math.trunc(v):>7}{round(v):>7}")

print("\nround usa arredondamento bancário:")
print(round(0.5), round(1.5), round(2.5), round(3.5))

import math

for graus in [0, 30, 45, 60, 90]:
    rad = math.radians(graus)
    print(f"{graus:>3}° = {rad:.4f} rad   "
          f"sen={math.sin(rad):.4f}  cos={math.cos(rad):.4f}")

print("\narco tangente de (1,1):",
      math.degrees(math.atan2(1, 1)), "graus")

import math

def watts_para_dbm(p_watts):
    return 10 * math.log10(p_watts * 1000)

def dbm_para_watts(p_dbm):
    return 10 ** (p_dbm / 10) / 1000

for p in [0.001, 0.01, 0.1, 1.0]:
    print(f"{p:>6} W = {watts_para_dbm(p):>6.1f} dBm")

print("\n30 dBm =", dbm_para_watts(30), "W")
print("ganho de tensão 100x =", 20 * math.log10(100), "dB")
print("log natural, base 2, base 10:",
      math.log(math.e), math.log2(1024), math.log10(1e6))

from decimal import Decimal, getcontext
from fractions import Fraction

print("float:", 0.1 + 0.2)
print("Decimal:", Decimal("0.1") + Decimal("0.2"))

getcontext().prec = 6
print("divisão com 6 dígitos:", Decimal(1) / Decimal(7))

print("fração:", Fraction(1, 3) + Fraction(1, 6))
print("de float para fração:", Fraction(0.25))

import cmath
import math

z = complex(3, 4)

print("z =", z)
print("módulo:", abs(z))
print("fase em graus:", math.degrees(cmath.phase(z)))
print("polar:", cmath.polar(z))
print("de volta para retangular:", cmath.rect(5, cmath.phase(z)))

v = cmath.rect(220, math.radians(30))   # tensao 220 V, 30 graus
i = cmath.rect(5, math.radians(-15))    # corrente 5 A
print("impedância:", abs(v / i), "ohms")

import math

def raizes(a, b, c):
    """Devolve as raízes reais ou complexas de ax² + bx + c."""
    delta = b ** 2 - 4 * a * c
    if delta >= 0:
        raiz = math.sqrt(delta)
        return ((-b + raiz) / (2 * a), (-b - raiz) / (2 * a))
    raiz = complex(0, math.sqrt(-delta))
    return ((-b + raiz) / (2 * a), (-b - raiz) / (2 * a))

for coef in [(1, -5, 6), (1, 2, 5), (2, 4, 2)]:
    print(f"{coef} -> {raizes(*coef)}")

import math

def perda_espaco_livre(distancia_km, frequencia_mhz):
    """Perda de propagação em espaço livre, em dB."""
    return (32.44 + 20 * math.log10(distancia_km)
            + 20 * math.log10(frequencia_mhz))

def potencia_recebida(pt_dbm, gt, gr, d_km, f_mhz):
    return pt_dbm + gt + gr - perda_espaco_livre(d_km, f_mhz)

print(f"{'d (km)':>8}{'perda (dB)':>13}{'Prx (dBm)':>12}")
for d in [1, 5, 10, 50]:
    perda = perda_espaco_livre(d, 2400)
    prx = potencia_recebida(20, 12, 2, d, 2400)
    print(f"{d:>8}{perda:>13.2f}{prx:>12.2f}")

import random

random.seed(7)

print("float em [0,1):", random.random())
print("inteiro de 1 a 6:", random.randint(1, 6))
print("inteiro em passo de 5:", random.randrange(0, 101, 5))
print("real entre 1.5 e 2.5:", random.uniform(1.5, 2.5))

import random

random.seed(7)
equipamentos = ["antena", "cabo", "rádio", "filtro", "fonte"]

print("um item:", random.choice(equipamentos))
print("três sem repetir:", random.sample(equipamentos, 3))
print("três com repetição:", random.choices(equipamentos, k=3))
print("com pesos:", random.choices(["ok", "falha"],
                                   weights=[9, 1], k=10))

baralho = list(range(1, 11))
random.shuffle(baralho)
print("embaralhado:", baralho)

import random
import statistics

random.seed(7)

normal = [random.gauss(mu=0, sigma=1) for _ in range(10_000)]
expo = [random.expovariate(lambd=0.5) for _ in range(10_000)]

print(f"normal  média {statistics.mean(normal):+.4f} "
      f"desvio {statistics.stdev(normal):.4f}")
print(f"expon.  média {statistics.mean(expo):.4f} "
      f"esperado {1 / 0.5:.4f}")

import random

def estimar_pi(pontos):
    random.seed(42)
    dentro = 0
    for _ in range(pontos):
        x, y = random.random(), random.random()
        if x * x + y * y <= 1:
            dentro += 1
    return 4 * dentro / pontos

for n in [100, 10_000, 1_000_000]:
    print(f"{n:>9} pontos -> pi ≈ {estimar_pi(n):.5f}")

import random

def simular_enlace(bits, prob_erro):
    random.seed(1)
    erros = sum(1 for _ in range(bits)
                if random.random() < prob_erro)
    return erros, erros / bits

for p in [1e-2, 1e-3, 1e-4]:
    erros, ber = simular_enlace(100_000, p)
    print(f"p={p:<7} erros={erros:<5} BER medida={ber:.5f}")

import random

random.seed(3)
lancamentos = [random.randint(1, 6) + random.randint(1, 6)
               for _ in range(1000)]

for face in range(2, 13):
    n = lancamentos.count(face)
    print(f"{face:>3} {'#' * (n // 5):<28} {n:>4}")

import statistics as stat

medidas = [12.5, 13.0, 11.8, 12.9, 12.1, 13.4, 12.6]

print("média:", round(stat.mean(medidas), 4))
print("mediana:", stat.median(medidas))
print("moda:", stat.mode([1, 2, 2, 3, 3, 3]))
print("média geométrica:", round(stat.geometric_mean([1, 4, 16]), 4))
print("média harmônica:", round(stat.harmonic_mean([40, 60]), 4))

import statistics as stat

amostra = [12.5, 13.0, 11.8, 12.9, 12.1, 13.4, 12.6]

print("amplitude:", max(amostra) - min(amostra))
print("variância amostral:", round(stat.variance(amostra), 5))
print("desvio amostral:", round(stat.stdev(amostra), 5))
print("variância populacional:", round(stat.pvariance(amostra), 5))
print("desvio populacional:", round(stat.pstdev(amostra), 5))

media = stat.mean(amostra)
cv = stat.stdev(amostra) / media * 100
print(f"coeficiente de variação: {cv:.2f}%")

import statistics as stat

dados = [3, 7, 8, 5, 12, 14, 21, 13, 18, 9, 6, 11]
dados.sort()

q1, q2, q3 = stat.quantiles(dados, n=4)
print("mínimo:", min(dados))
print("Q1:", q1)
print("mediana:", q2)
print("Q3:", q3)
print("máximo:", max(dados))
print("intervalo interquartil:", q3 - q1)

limite = q3 + 1.5 * (q3 - q1)
print("possíveis outliers:", [d for d in dados if d > limite])

import statistics as stat

distancia = [1, 2, 3, 4, 5, 6, 7, 8]        # km
potencia = [-52, -58, -61, -64, -66, -68, -69, -71]  # dBm

print("correlação:", round(stat.correlation(distancia, potencia), 4))
print("covariância:", round(stat.covariance(distancia, potencia), 4))

reta = stat.linear_regression(distancia, potencia)
print(f"modelo: P = {reta.slope:.3f} * d + {reta.intercept:.3f}")

for d in [2.5, 9]:
    print(f"previsto em {d} km:"
          f" {reta.slope * d + reta.intercept:.2f} dBm")

from statistics import NormalDist

ruido = NormalDist(mu=0, sigma=2)      # media 0, desvio 2

print("densidade em 0:", round(ruido.pdf(0), 5))
print("P(X < 2):", round(ruido.cdf(2), 5))
print("P(-2 < X < 2):", round(ruido.cdf(2) - ruido.cdf(-2), 5))
print("percentil 95:", round(ruido.inv_cdf(0.95), 4))

amostra = [11.9, 12.4, 12.1, 12.8, 12.0, 12.5]
ajuste = NormalDist.from_samples(amostra)
print(f"ajuste: mu={ajuste.mean:.4f} sigma={ajuste.stdev:.4f}")

import statistics as stat

def resumo(nome, dados):
    q1, q2, q3 = stat.quantiles(dados, n=4)
    linhas = [
        ("n", len(dados)),
        ("média", round(stat.mean(dados), 3)),
        ("mediana", round(q2, 3)),
        ("desvio", round(stat.stdev(dados), 3)),
        ("mínimo", min(dados)),
        ("máximo", max(dados)),
        ("Q1 / Q3", f"{q1:.2f} / {q3:.2f}"),
    ]
    print(f"== {nome} ==")
    for rotulo, valor in linhas:
        print(f"{rotulo:<10}{valor}")
    print()

resumo("RSSI antena A", [-52, -58, -61, -54, -66, -59, -57, -60])
resumo("RSSI antena B", [-48, -50, -49, -51, -47, -52, -50, -49])

import numpy as np

a = np.array([1, 2, 3, 4])
zeros = np.zeros(5)
uns = np.ones((2, 3))
faixa = np.arange(0, 10, 2)
pontos = np.linspace(0, 1, 5)      # inclui o extremo

print(a)
print(zeros)
print(uns)
print(faixa)
print(pontos)

import numpy as np

m = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])

print("shape:", m.shape)
print("dimensões:", m.ndim)
print("elementos:", m.size)
print("tipo:", m.dtype)
print("bytes por item:", m.itemsize)

inteiros = np.array([1, 2, 3], dtype=np.int16)
print(inteiros.dtype, inteiros.astype(float))

import numpy as np
import time

n = 2_000_000
lista = list(range(n))
vetor = np.arange(n)

inicio = time.perf_counter()
quadrados = [x * x for x in lista]
t_lista = time.perf_counter() - inicio

inicio = time.perf_counter()
quadrados_np = vetor ** 2
t_numpy = time.perf_counter() - inicio

print(f"lista Python: {t_lista:.4f} s")
print(f"NumPy:        {t_numpy:.4f} s")
print(f"ganho: {t_lista / t_numpy:.0f} vezes")
print("mesmo resultado?", quadrados[-1] == quadrados_np[-1])

import numpy as np

rssi = np.array([-52, -58, -61, -47, -66, -59, -71, -55])

print("primeiro e último:", rssi[0], rssi[-1])
print("três primeiros:", rssi[:3])
print("de dois em dois:", rssi[::2])

forte = rssi > -60                 # mascara booleana
print("máscara:", forte)
print("valores fortes:", rssi[forte])
print("quantos fortes:", forte.sum())
print("índices dos fracos:", np.where(rssi <= -60)[0])

rssi[rssi < -70] = -70             # limita o piso
print("após saturar:", rssi)

import numpy as np

medidas = np.array([[10.0, 11.0, 12.0],
                    [20.0, 21.0, 22.0]])

print(medidas + 100)          # escalar aplicado a tudo
print(medidas * 2)

offset = np.array([1, 2, 3])  # aplicado linha a linha
print(medidas + offset)

coluna = np.array([[0.0], [100.0]])
print(medidas + coluna)

import numpy as np

notas = np.array([[8.5, 9.0, 7.5],
                  [7.0, 6.5, 8.0],
                  [9.5, 9.0, 9.2]])

print("média geral:", notas.mean().round(3))
print("média por aluno (linha):", notas.mean(axis=1).round(2))
print("média por prova (coluna):", notas.mean(axis=0).round(2))
print("desvio geral:", notas.std(ddof=1).round(4))
print("maior nota:", notas.max(), "na posição",
      np.unravel_index(notas.argmax(), notas.shape))
print("soma acumulada da primeira linha:", notas[0].cumsum())

import numpy as np

A = np.array([[2.0, 1.0], [1.0, 3.0]])
b = np.array([8.0, 13.0])

print("transposta:\n", A.T)
print("produto matricial:\n", A @ A)
print("determinante:", round(np.linalg.det(A), 4))
print("inversa:\n", np.linalg.inv(A).round(4))

x = np.linalg.solve(A, b)      # resolve A x = b
print("solução do sistema:", x)
print("verificação:", A @ x)

import numpy as np

fs = 1000                       # taxa de amostragem (Hz)
t = np.linspace(0, 1, fs, endpoint=False)

sinal = 2.0 * np.sin(2 * np.pi * 50 * t)      # 50 Hz
sinal += 0.5 * np.sin(2 * np.pi * 120 * t)    # 120 Hz

gerador = np.random.default_rng(42)
ruido = gerador.normal(0, 0.3, size=t.size)
medido = sinal + ruido

print("amostras:", medido.size)
print("primeiras cinco:", medido[:5].round(4))
print("valor eficaz (RMS):", np.sqrt(np.mean(medido ** 2)).round(4))
potencia = np.mean(medido ** 2)
print("potência média:", potencia.round(4),
      "=", (10 * np.log10(potencia)).round(2), "dB")

import numpy as np

fs = 1000
t = np.linspace(0, 1, fs, endpoint=False)
sinal = 2 * np.sin(2 * np.pi * 50 * t) + 0.5 * np.sin(
    2 * np.pi * 120 * t)

espectro = np.fft.rfft(sinal)
freq = np.fft.rfftfreq(t.size, d=1 / fs)
amplitude = 2 * np.abs(espectro) / t.size

picos = np.argsort(amplitude)[-2:][::-1]
for i in picos:
    print(f"componente em {freq[i]:>6.1f} Hz "
          f"com amplitude {amplitude[i]:.3f}")

import numpy as np

dados = np.array([[1.0, -52.3], [2.0, -58.1], [3.0, -61.7]])

np.savetxt("medidas.csv", dados, delimiter=",",
           header="distancia_km,rssi_dbm", comments="",
           fmt="%.2f")
lido = np.loadtxt("medidas.csv", delimiter=",", skiprows=1)
print(lido)

np.save("medidas.npy", dados)        # formato binario do NumPy
print("binário confere?", np.array_equal(np.load("medidas.npy"),
                                         dados))

import matplotlib.pyplot as plt
import numpy as np

t = np.linspace(0, 1, 500)
y = np.sin(2 * np.pi * 5 * t)

plt.figure(figsize=(6.4, 2.8))
plt.plot(t, y)
plt.savefig("g01.png", dpi=100, bbox_inches="tight")
print("figura gravada")

import matplotlib.pyplot as plt
import numpy as np

t = np.linspace(0, 1, 500)

plt.figure(figsize=(6.4, 2.8))
plt.plot(t, np.sin(2 * np.pi * 5 * t), label="5 Hz",
         color="#2f9e41")
plt.title("Sinal senoidal")
plt.xlabel("tempo (s)")
plt.ylabel("amplitude (V)")
plt.grid(True, linestyle=":", alpha=0.6)
plt.legend(loc="upper right")
plt.savefig("g02.png", dpi=100, bbox_inches="tight")
print("ok")

import matplotlib.pyplot as plt
import numpy as np

t = np.linspace(0, 1, 500)

plt.figure(figsize=(6.4, 3.0))
plt.plot(t, np.sin(2 * np.pi * 3 * t), "-",
         color="#2f9e41", label="3 Hz")
plt.plot(t, 0.6 * np.sin(2 * np.pi * 6 * t), "--",
         color="#cd191e", label="6 Hz")
plt.plot(t, 0.3 * np.sin(2 * np.pi * 12 * t), ":",
         color="#101214", label="12 Hz")
plt.xlabel("tempo (s)")
plt.ylabel("amplitude")
plt.legend(ncol=3, fontsize=8)
plt.grid(alpha=0.3)
plt.savefig("g03.png", dpi=100, bbox_inches="tight")
print("três curvas")

import matplotlib.pyplot as plt
import numpy as np

d = np.array([1, 2, 3, 4, 5, 6, 7, 8], dtype=float)
p = np.array([-52, -58, -61, -64, -66, -68, -69, -71], dtype=float)

coef = np.polyfit(np.log10(d), p, 1)
ajuste = np.polyval(coef, np.log10(d))

plt.figure(figsize=(6.4, 3.0))
plt.scatter(d, p, color="#cd191e", label="medido", zorder=3)
plt.plot(d, ajuste, color="#2f9e41",
         label=f"ajuste: {coef[0]:.1f} log(d) {coef[1]:+.1f}")
plt.xlabel("distância (km)")
plt.ylabel("potência recebida (dBm)")
plt.legend(fontsize=8)
plt.grid(alpha=0.3)
plt.savefig("g04.png", dpi=100, bbox_inches="tight")
print("coeficientes:", coef.round(3))

import matplotlib.pyplot as plt

disciplinas = ["Prog I", "Redes", "Sinais", "Antenas"]
medias = [7.8, 8.4, 6.9, 7.2]

plt.figure(figsize=(6.4, 2.8))
barras = plt.bar(disciplinas, medias, color="#2f9e41", width=0.55)
barras[medias.index(min(medias))].set_color("#cd191e")

for x, v in enumerate(medias):
    plt.text(x, v + 0.1, f"{v:.1f}", ha="center", fontsize=8)

plt.ylim(0, 10)
plt.ylabel("média da turma")
plt.savefig("g05.png", dpi=100, bbox_inches="tight")
print("média geral:", round(sum(medias) / len(medias), 2))

import matplotlib.pyplot as plt
import numpy as np

gerador = np.random.default_rng(7)
ruido = gerador.normal(loc=0, scale=1, size=5000)

plt.figure(figsize=(6.4, 2.8))
plt.hist(ruido, bins=40, color="#2f9e41", edgecolor="white")
plt.axvline(ruido.mean(), color="#cd191e", linestyle="--",
            label=f"média {ruido.mean():.3f}")
plt.xlabel("amplitude")
plt.ylabel("ocorrências")
plt.legend(fontsize=8)
plt.savefig("g06.png", dpi=100, bbox_inches="tight")
print("desvio padrão:", round(ruido.std(ddof=1), 4))

import matplotlib.pyplot as plt
import numpy as np

t = np.linspace(0, 1, 400)
fig, eixos = plt.subplots(2, 2, figsize=(6.6, 3.6))

eixos[0, 0].plot(t, np.sin(2 * np.pi * 3 * t), color="#2f9e41")
eixos[0, 0].set_title("senoide", fontsize=9)

eixos[0, 1].plot(t, np.sign(np.sin(2 * np.pi * 3 * t)),
                 color="#cd191e")
eixos[0, 1].set_title("quadrada", fontsize=9)

eixos[1, 0].plot(t, 2 * (t % 0.33) / 0.33 - 1, color="#101214")
eixos[1, 0].set_title("dente de serra", fontsize=9)

eixos[1, 1].plot(t, np.exp(-4 * t), color="#2f9e41")
eixos[1, 1].set_title("exponencial", fontsize=9)

for eixo in eixos.flat:
    eixo.grid(alpha=0.3)
    eixo.tick_params(labelsize=7)

fig.tight_layout()
fig.savefig("g07.png", dpi=100, bbox_inches="tight")
print("quatro painéis")

import matplotlib.pyplot as plt
import numpy as np

f = np.logspace(1, 5, 400)        # 10 Hz a 100 kHz
fc = 1000.0
ganho_db = -20 * np.log10(np.sqrt(1 + (f / fc) ** 2))

plt.figure(figsize=(6.4, 2.9))
plt.semilogx(f, ganho_db, color="#2f9e41")
plt.axvline(fc, color="#cd191e", linestyle="--",
            label="corte 1 kHz")
plt.axhline(-3, color="#101214", linestyle=":", label="-3 dB")
plt.xlabel("frequência (Hz)")
plt.ylabel("ganho (dB)")
plt.grid(which="both", alpha=0.3)
plt.legend(fontsize=8)
plt.savefig("g08.png", dpi=100, bbox_inches="tight")
print("ganho na frequência de corte:",
      round(-20 * np.log10(np.sqrt(2)), 3), "dB")

import matplotlib.pyplot as plt
import numpy as np

fs = 1000
t = np.linspace(0, 1, fs, endpoint=False)
sinal = (2 * np.sin(2 * np.pi * 50 * t)
         + 0.5 * np.sin(2 * np.pi * 120 * t))
sinal += np.random.default_rng(1).normal(0, 0.3, t.size)

freq = np.fft.rfftfreq(t.size, 1 / fs)
amp = 2 * np.abs(np.fft.rfft(sinal)) / t.size

fig, (cima, baixo) = plt.subplots(2, 1, figsize=(6.4, 4.0))

cima.plot(t[:200], sinal[:200], color="#2f9e41", linewidth=0.9)
cima.set_title("sinal no tempo (200 amostras)", fontsize=9)
cima.set_xlabel("t (s)", fontsize=8)

baixo.plot(freq, amp, color="#cd191e", linewidth=0.9)
baixo.set_xlim(0, 200)
baixo.set_title("espectro de amplitude", fontsize=9)
baixo.set_xlabel("frequência (Hz)", fontsize=8)

for eixo in (cima, baixo):
    eixo.grid(alpha=0.3)
    eixo.tick_params(labelsize=7)

fig.tight_layout()
fig.savefig("g09.png", dpi=100, bbox_inches="tight")
print("pico em", round(freq[np.argmax(amp)], 1), "Hz")

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)

plt.figure(figsize=(6.4, 2.6))
plt.plot(x, np.exp(-x / 3) * np.cos(2 * x), color="#2f9e41")
plt.title("resposta amortecida")
plt.tight_layout()

plt.savefig("figura.png", dpi=300)   # imagem para impressao
plt.savefig("figura.pdf")            # vetorial, sem perda
plt.savefig("figura.svg")            # vetorial para a web

import os
for arquivo in sorted(os.listdir(".")):
    if arquivo.startswith("figura"):  # png, pdf e svg
        tamanho = os.path.getsize(arquivo) // 1024
        print(f"{arquivo:<22}{tamanho:>5} KB")

import pandas as pd

s = pd.Series([-52.3, -58.1, -61.7], index=["1 km", "2 km", "3 km"])
print(s)
print("média:", round(s.mean(), 3))

df = pd.DataFrame({
    "sensor": ["ant-01", "ant-02", "ant-01", "ant-02"],
    "distancia_km": [1.0, 1.0, 5.0, 5.0],
    "rssi_dbm": [-52.3, -49.8, -66.1, -62.4],
})
print()
print(df)

import pandas as pd

with open("medidas.csv", "w", encoding="utf-8") as f:
    f.write("data,sensor,distancia_km,rssi_dbm\n")
    linhas = [
        ("2026-07-20", "ant-01", 1.0, -52.3),
        ("2026-07-20", "ant-02", 1.0, -49.8),
        ("2026-07-21", "ant-01", 5.0, -66.1),
        ("2026-07-21", "ant-02", 5.0, -62.4),
        ("2026-07-22", "ant-01", 10.0, -71.5),
        ("2026-07-22", "ant-02", 10.0, -68.9),
    ]
    for linha in linhas:
        f.write(",".join(str(c) for c in linha) + "\n")

df = pd.read_csv("medidas.csv", parse_dates=["data"])
print(df.head())
print("\nformato:", df.shape)
print("colunas:", list(df.columns))

import pandas as pd

df = pd.DataFrame({
    "sensor": ["ant-01", "ant-02"] * 3,
    "distancia_km": [1.0, 1.0, 5.0, 5.0, 10.0, 10.0],
    "rssi_dbm": [-52.3, -49.8, -66.1, -62.4, -71.5, -68.9],
})

print(df.dtypes)
print("\nresumo estatístico:")
print(df.describe().round(2))

import pandas as pd

df = pd.DataFrame({
    "sensor": ["ant-01", "ant-02"] * 3,
    "distancia_km": [1.0, 1.0, 5.0, 5.0, 10.0, 10.0],
    "rssi_dbm": [-52.3, -49.8, -66.1, -62.4, -71.5, -68.9],
})

print("uma coluna:\n", df["rssi_dbm"].values)
print("\nduas colunas:\n", df[["sensor", "rssi_dbm"]].head(3))
print("\npor posição (iloc):\n", df.iloc[0])
print("\nfiltro booleano:")
print(df[df["rssi_dbm"] > -65])
print("\nfiltro composto:")
print(df[(df["sensor"] == "ant-01") & (df["distancia_km"] >= 5)])

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "sensor": ["ant-01", "ant-02"] * 3,
    "distancia_km": [1.0, 1.0, 5.0, 5.0, 10.0, 10.0],
    "rssi_dbm": [-52.3, -49.8, -66.1, -62.4, -71.5, -68.9],
})

df["potencia_mw"] = (10 ** (df["rssi_dbm"] / 10)).round(6)
df["qualidade"] = np.where(df["rssi_dbm"] > -65, "boa", "fraca")

print(df.sort_values("rssi_dbm", ascending=False))
print("\ncontagem por qualidade:")
print(df["qualidade"].value_counts())

import pandas as pd

df = pd.DataFrame({
    "sensor": ["ant-01", "ant-02"] * 3,
    "distancia_km": [1.0, 1.0, 5.0, 5.0, 10.0, 10.0],
    "rssi_dbm": [-52.3, -49.8, -66.1, -62.4, -71.5, -68.9],
})

print("média por sensor:")
print(df.groupby("sensor")["rssi_dbm"].mean().round(2))

print("\nresumo por sensor:")
print(df.groupby("sensor")["rssi_dbm"]
        .agg(["count", "mean", "min", "max"]).round(2))

print("\ntabela cruzada:")
print(df.pivot_table(values="rssi_dbm", index="distancia_km",
                     columns="sensor").round(2))

import pandas as pd
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "distancia_km": [1.0, 5.0, 10.0],
    "ant-01": [-52.3, -66.1, -71.5],
    "ant-02": [-49.8, -62.4, -68.9],
}).set_index("distancia_km")

eixo = df.plot(marker="o", figsize=(6.4, 2.9),
               color=["#2f9e41", "#cd191e"])
eixo.set_xlabel("distância (km)")
eixo.set_ylabel("RSSI (dBm)")
eixo.grid(alpha=0.3)
plt.savefig("g10.png", dpi=100, bbox_inches="tight")
print(df)

import pandas as pd

df = pd.DataFrame({
    "sensor": ["ant-01", "ant-02"],
    "rssi_dbm": [-52.3, -49.8],
})

df.to_csv("saida.csv", index=False)
df.to_json("saida.json", orient="records", indent=2)

print(open("saida.csv", encoding="utf-8").read())
print(open("saida.json", encoding="utf-8").read())

import numpy as np
import pandas as pd

gerador = np.random.default_rng(2026)
distancias = np.array([1, 2, 5, 10, 20, 50], dtype=float)

registros = []
for sensor, offset in [("ant-01", 0.0), ("ant-02", 3.5)]:
    for d in distancias:
        for repeticao in range(5):
            teorico = -40 - 20 * np.log10(d)
            medido = teorico + offset + gerador.normal(0, 1.5)
            registros.append((sensor, d, repeticao + 1,
                              round(medido, 2)))

df = pd.DataFrame(registros, columns=["sensor", "distancia_km",
                                      "repeticao", "rssi_dbm"])
df.to_csv("campanha.csv", index=False)
print(df.head())
print("total de medidas:", len(df))

import numpy as np
import pandas as pd

gerador = np.random.default_rng(2026)
registros = []
for sensor, offset in [("ant-01", 0.0), ("ant-02", 3.5)]:
    for d in [1, 2, 5, 10, 20, 50]:
        for r in range(5):
            registros.append(
                (sensor, float(d),
                 -40 - 20 * np.log10(d) + offset
                 + gerador.normal(0, 1.5)))
df = pd.DataFrame(registros,
                  columns=["sensor", "distancia_km", "rssi_dbm"])

resumo = (df.groupby(["sensor", "distancia_km"])["rssi_dbm"]
            .agg(["mean", "std", "count"]).round(2))
print(resumo)

for sensor, grupo in df.groupby("sensor"):
    coef = np.polyfit(np.log10(grupo["distancia_km"]),
                      grupo["rssi_dbm"], 1)
    print(f"\n{sensor}: expoente de perda n = "
          f"{-coef[0] / 10:.2f}, referência {coef[1]:.2f} dBm")

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

gerador = np.random.default_rng(2026)
registros = []
for sensor, offset in [("ant-01", 0.0), ("ant-02", 3.5)]:
    for d in [1, 2, 5, 10, 20, 50]:
        for r in range(5):
            registros.append(
                (sensor, float(d),
                 -40 - 20 * np.log10(d) + offset
                 + gerador.normal(0, 1.5)))
df = pd.DataFrame(registros,
                  columns=["sensor", "distancia_km", "rssi_dbm"])

fig, (esq, dir_) = plt.subplots(1, 2, figsize=(6.8, 2.9))
cores = {"ant-01": "#2f9e41", "ant-02": "#cd191e"}

for sensor, grupo in df.groupby("sensor"):
    media = grupo.groupby("distancia_km")["rssi_dbm"].mean()
    desvio = grupo.groupby("distancia_km")["rssi_dbm"].std()
    esq.errorbar(media.index, media.values, yerr=desvio.values,
                 marker="o", capsize=3, color=cores[sensor],
                 label=sensor)
    dir_.hist(grupo["rssi_dbm"] - grupo["rssi_dbm"].mean(),
              bins=12, alpha=0.6, color=cores[sensor],
              label=sensor)

esq.set_xscale("log")
esq.set_xlabel("distância (km)")
esq.set_ylabel("RSSI médio (dBm)")
esq.grid(alpha=0.3, which="both")
esq.legend(fontsize=8)

dir_.set_xlabel("desvio em torno da média (dB)")
dir_.set_ylabel("ocorrências")
dir_.legend(fontsize=8)

fig.tight_layout()
fig.savefig("g11.png", dpi=100, bbox_inches="tight")
print("figuras do relatório geradas")

import numpy as np
import pandas as pd
from datetime import date

gerador = np.random.default_rng(2026)
registros = []
for sensor, offset in [("ant-01", 0.0), ("ant-02", 3.5)]:
    for d in [1, 2, 5, 10, 20, 50]:
        for r in range(5):
            registros.append(
                (sensor, float(d),
                 -40 - 20 * np.log10(d) + offset
                 + gerador.normal(0, 1.5)))
df = pd.DataFrame(registros,
                  columns=["sensor", "distancia_km", "rssi_dbm"])

linhas = [
    "# Relatório de campanha de medidas",
    f"Data: {date(2026, 7, 22).strftime('%d/%m/%Y')}",
    f"Medidas: {len(df)}  |  Sensores: "
    f"{df['sensor'].nunique()}",
    "",
    "## Resumo por sensor",
    df.groupby("sensor")["rssi_dbm"]
      .agg(["count", "mean", "std"]).round(2).to_markdown(),
    "",
    "## Conclusão",
]

melhor = df.groupby("sensor")["rssi_dbm"].mean().idxmax()
linhas.append(f"O sensor {melhor} apresentou o melhor nível "
              f"médio de sinal.")

texto = "\n".join(linhas)
with open("relatorio.md", "w", encoding="utf-8") as f:
    f.write(texto)

print(texto)

# ---- numpy -----------------------------------------------------
import numpy as np
v = np.array([1, 2, 3]);        m = np.zeros((2, 3))
t = np.linspace(0, 1, 500);     f = np.arange(0, 10, 0.5)
v.mean(); v.std(ddof=1); v.sum(); v.max(); v.argmax()
m.shape; m.reshape(3, 2); m.T; m @ m.T
v[v > 2];  np.where(v > 2);  np.linalg.solve(A, b)
rng = np.random.default_rng(42);  rng.normal(0, 1, 100)
np.fft.rfft(sinal); np.fft.rfftfreq(n, 1 / fs)

# ---- matplotlib ------------------------------------------------
import matplotlib.pyplot as plt
plt.figure(figsize=(6.4, 3))
plt.plot(x, y, label="curva");  plt.scatter(x, y)
plt.bar(rotulos, valores);      plt.hist(dados, bins=30)
plt.semilogx(f, ganho);         plt.xlabel("t (s)")
plt.legend(); plt.grid(alpha=0.3); plt.tight_layout()
plt.savefig("figura.png", dpi=300, bbox_inches="tight")
fig, eixos = plt.subplots(2, 1, figsize=(6, 4))

# ---- pandas ----------------------------------------------------
import pandas as pd
df = pd.read_csv("dados.csv")
df.head(); df.describe(); df.dtypes; df.shape
df["coluna"]; df[["a", "b"]]; df.iloc[0]; df.loc[df.a > 1]
df["nova"] = df["a"] * 2
df.groupby("sensor")["valor"].agg(["mean", "std"])
df.sort_values("valor", ascending=False)
df.to_csv("saida.csv", index=False)