Sou o Camilo, teu professor de TI. Chegamos no tema mais estranho da série — e também no mais barato de blindar. Aqui a gente NÃO vai virar programador. A gente vai aprender a ler um código de 4 linhas e dizer o que ele faz. É só isso que a FCC pede. Pega firme num ponto: a leitura de Pandas. O resto é seguro.
⚖️ HONESTIDADE PRIMEIRO (leia isto antes de tudo): o edital do CE NÃO nomina "Python" explicitamente. Ele pede SQL / DQL (consulta de dados) por escrito. Então Python é HEDGE de risco assimétrico — não é certeza.
🎲 O que é "risco assimétrico" (em português): é uma aposta onde você arrisca pouco e pode ganhar muito. Estudar o reconhecimento de código Pandas custa ~1h. Se NÃO cair → você perdeu 1h. Se CAIR → você pega um ponto que quase TODO concorrente deixou em branco (porque ninguém estudou). Barato de blindar, caro de ignorar.
⚡ O número que sustenta a aposta: na SEFAZ-MT 2026 (prova-irmã FCC) caíram 5 questões de Python/Pandas (3 de manipulação + 2 de visualização) (pd.Grouper, merge how, dicionário acumulador, gráfico de série temporal, boxplot de outliers) + 1 de ETL feita em Pandas = 6 trechos de código que você resolve lendo Pandas. Confirmadas no banco (você resolve TODAS hoje).
👻 O ponto-cego dos cursinhos: NENHUM professor de reta-final destilou Python. O Lucas Ianni tinha o material (Parte 5-6, Pandas/NumPy) e não entregou. A única fonte real do acervo é o Guia "Python para Concursos" do Felipe Mathias — é nele que esta aula se apoia.
🧭 Tradução do Camilo: a Aula 0 te avisou que a FCC não pede mais que você DEFINA, ela pede que você FAÇA. Esta aula é a prova viva disso. Aqui é drill puro — ler código, não decorar conceito.
Hueliton Fontes — 26º lugar SEFAZ-AP (FCC), 42 anos, ex-militar, partiu do ZERO em TI.
🎯 A tática dele: "eu tinha verdadeiro pavor de TI" → mirou só os tópicos mais prováveis e fez 80% em Fluência. Não tentou ser nerd de Python — aprendeu a reconhecer o que cada coisa faz e seguiu.
💎 O ouro pra esta aula: você NÃO precisa saber escrever Pandas de cabeça. Precisa bater o olho e reconhecer: "isso aqui é um groupby por duas chaves", "isso é um left join". 42 anos, militar, do zero, 80%. Esse é você. O reconhecimento de código é decoreba visual, não engenharia.
Gabriel Santana — 1º lugar SEFAZ-GO 2026 (FCC). (GO é o espelho do edital do CE.)
| Aula | Tema | 💰 Peso |
|---|---|---|
| 00 | Fundamentos (tipos de dado, DIKW, ciclo de vida) | 🛡️ blindagem · ✅ no ar |
| 01 | CRISP-DM (as 6 fases na ordem) | 🥉 alto · ✅ no ar |
| 02 | Arquitetura & Eng. de Dados (DW/Lake/Lakehouse, ETL×ELT, OLAP, DAG) | 🥇 ouro |
| 03 | Banco de Dados & SQL (relacional, normalização, NoSQL, SQL na mão) | 🥇 OURO |
| 04 | Machine Learning & IA (sup × não-sup, clusterização, over/underfit, Lasso/Ridge) | 👑 OURO MÁXIMO (7 de 11 em SP) |
| 05 | Governança & Ética de Dados (qualidade, viés, IA generativa) | 🟡 médio |
| 06 | Segurança / LGPD / Sigilo Fiscal (CID, LGPD, CTN 198 + IN SEFAZ-CE 92/21) | 🟡 médio |
| 07 ⬅️ (esta) | Python / Pandas / NumPy (ler código) | 👻 órfão eliminatório (hedge) |
🔑 Leitura do mapa: o ouro de pontos está nas Aulas 02-04 (arquitetura, SQL, ML). Esta Aula 07 é a apólice de seguro — você a estuda DEPOIS de blindar o ouro, mas ela existe porque, se a FCC trouxer Pandas (como fez em MT), o concorrente que pulou Python zera essas questões e você pega sozinho.
Eles são INSUMO — a palavra final é minha. Faro = quão bem cada um previu o que a FCC 2026 cobrou de Python.
| Prof | Faro p/ Python | Confie nele para... |
|---|---|---|
| Felipe Mathias (TI Descompl.) | 10/10 | A ÚNICA fonte real. Guia "Python para Concursos" — sintaxe, listas, recursão, NumPy, Pandas. Tudo que esta aula usa sai dele. |
| Lucas Ianni (Estratégia) | 2/10 | ⚠️ tinha o material (Pandas/NumPy, "Parte 5-6") mas NÃO destilou na reta final — o maior buraco do acervo. |
| Renato da Costa (prof da reta final do CE no Estratégia) | 0/10 | ❌ empurrou SQL/Python "pra aula 2" e não cobriu — e a prova cobrou. |
| Demais cursinhos | 0/10 | ⚪ Python foi órfão total nas reta-finais. |
⚠️ HONESTIDADE OBRIGATÓRIA: este é o tema com o maior abismo entre o que caiu e o que foi ensinado. Caiu pesado (MT: 5q de Python/Pandas + 1 de ETL em Pandas) e ninguém ensinou (só o Mathias, num guia que a maioria nem viu). É exatamente por isso que vale o nosso 1h: onde todo mundo está cego, quem enxerga um pouquinho já lidera.
🎯 A FCC NÃO te pede pra ESCREVER código. Ela te dá um cenário fazendário (ICMS por município, autos de infração, NF-e) + um requisito ("total mensal por município sem perder granularidade") + 5 trechos de código e pergunta: qual faz o que eu pedi? É múltipla escolha de leitura, não de programação.
⚡ A dica de prova nº 1 (igual às outras aulas): leia o REQUISITO primeiro (a frase que diz o que tem que acontecer). Depois leia as alternativas uma a uma, traduzindo o código pra português, e marque a que cumpre o requisito. As outras 4 sempre têm um erro plantado (ordem trocada, operação errada, "aproxima" em vez de "exato").
🪤 A pegadinha-mãe do Pandas: a FCC adora trocar a ORDEM das operações (groupby().resample() × resample().groupby()) — a ordem muda o resultado. E adora "aproximar" (rolling('30D') aproxima o mês; pd.Grouper(freq='M') acerta o mês civil).
🔗 Conexão (não-ilha): lembra da Aula 04 (pré-processamento) — limpar CNPJ com regex, tratar faltantes, padronizar datas? Tudo aquilo é feito EM PANDAS. O df que você vai ler aqui é o mesmo df que limpa os 2,3 milhões de declarações da prova de SP. Python é o braço que executa o pré-processamento que você já viu.
🔑 Bordão da aula: na FCC, Python não se escreve — se LÊ. Traduz o código pra português e marca o que faz o que o requisito pede.
Bloco 1 — Sintaxe-base (a base barata): tipos, listas/dicionários, fatiamento, for, def, list comprehension — só o necessário pra ler o resto.
Bloco 2 — NumPy: array × lista, vetorização (operação elemento a elemento), dimensões pelos colchetes.
Bloco 3 — PANDAS, o coração 🔴: Series/DataFrame, loc/iloc, filtro booleano, groupby + agg, pd.Grouper(freq='M'), merge/join (how=left/inner/outer), resample, pivot_table, dicionário acumulador, apply. É onde mora o ponto.
Bloco 4 — Visualização (matplotlib/seaborn) 🟡: gráfico de linha = série temporal · boxplot = outliers · histograma.
Bloco 5 — Ler código na prova: o método de tradução linha a linha + drill das 6 questões de MT (5 Pandas + 1 ETL em Pandas).
▶️ Próximo (Bloco 1): a sintaxe mínima pra você ler Pandas sem travar. Não é pra decorar — é pra reconhecer. Bora.
🎯 O que travar neste bloco (só o que serve pra LER código):
3 coleções: lista [ ] · dicionário {chave: valor} · tupla ( ).
A regra de ouro do Python: intervalo NÃO inclui o fim (range, fatiamento) — única exceção é np.linspace.
def = define função · for x in ... = repete · list comprehension = for compacto.
🟢 PROBABILIDADE PRO CE: BAIXA isolada, mas é PRÉ-REQUISITO. Sintaxe pura cai mais em prova que NÃO é fiscal. Aqui é a gramática que te deixa ler o Pandas do Bloco 3. Não martela — entende e segue.
O Guilherme (seu amigo auditor) tem uma lista dos valores de ICMS de 5 contribuintes da malha fiscal. Em Python isso é uma lista:
icms = [80000, 1500, 230000, 90, 45000]Ele quer só o primeiro e os três do meio. Aqui mora a pegadinha que persegue o Python inteiro:
icms[0] → 80000 (o índice começa em 0, não em 1).
icms[-1] → 45000 (índice negativo conta de trás pra frente).
icms[1:4] → [1500, 230000, 90] → pega do índice 1 ATÉ o 3 — o índice 4 NÃO entra.
🪤 A regra de ouro de TODO o Python (Mathias, literal): o valor que ABRE o intervalo entra; o que FECHA, NÃO entra. Vale pra range, pra fatiamento [i:f], pra tudo. icms[1:4] para no 3. É a pegadinha nº 1.
🧊 AS 3 COLEÇÕES QUE VOCÊ PRECISA RECONHECER (decore o delimitador)
| Coleção | Cara dela | Mutável? | Acessa por | Na sua mesa |
|---|---|---|---|---|
lista (list) |
[80000, 1500, 90] colchetes |
✅ sim | índice [0] |
a fila de valores de ICMS |
dicionário (dict) |
{"cnpj": "11...", "icms": 80000} chave:valor |
✅ sim | chave ["cnpj"] |
um registro de NF-e (campo→valor) |
tupla (tuple) |
(80000, 1500) parênteses |
❌ não | índice [0] |
um par fixo que não muda |
🔑 O macete visual (Mathias): olha o delimitador: [] = lista · {chave: valor} = dict · () = tupla. É só bater o olho.
🪤 PEGADINHA-OURO do dicionário: operação sobre dict por padrão usa as CHAVES, não os valores. sum(d) soma as chaves; pra somar valores é sum(d.values()). A FCC adora isso.
def (função) e for (repetição) — em 4 linhasdef total_icms(lista): # 'def' DEFINE uma função chamada total_icms
soma = 0
for valor in lista: # 'for' percorre CADA item da lista
soma += valor # soma += valor é soma = soma + valor
return soma # 'return' devolve o resultadodef nome(parametros): → cria a função. return → entrega o valor de volta.
for x in colecao: → repete o bloco pra cada elemento.
Indentação (os espaços) é OBRIGATÓRIA — é o que diz "isto está dentro do for/def". Python não usa { } nem ;. 🪤 Se a banca disser "não precisa indentar" → FALSO.
for compactado (a FCC está cobrando mais)É um jeito curto de criar uma lista nova a partir de outra. Lê-se da direção do for:
icms = [80000, 1500, 230000, 90, 45000]
altos = [v for v in icms if v > 50000] # "pega cada v de icms, SE v > 50000"
# resultado: [80000, 230000]🪤 Posição do if (Mathias — decide a questão):
só if (filtra) → vai no FIM: [v for v in icms if v > 50000].
if/else (transforma) → vem ANTES do for: [v if v > 50000 else 0 for v in icms].
O PLACAR DOS PROFESSORES — Sintaxe Python
Leitura do Camilo: sintaxe pura (range, listas, recursão) é o que o Mathias mais detalha no guia, porque cai em concurso geral. Pro nosso CE fiscal, a banca embrulha tudo em Pandas (Bloco 3) — então a sintaxe aqui é meio, não fim. Você decora o mínimo pra ler o Pandas e corre pro que dá ponto.
| Prof | Apostou? | Veredito | O que disse (literal do guia) |
|---|---|---|---|
| Felipe Mathias | ✅ forte | 🎯 base certa | "Listas: de longe a mais cobrada — intervalo não inclui o fim" · "sum(dict) soma as chaves" |
🪤 As pegadinhas de sintaxe que a FCC repete (do guia do Mathias):
Intervalo nunca inclui o fim (range, slice) — exceto np.linspace.
lista * 2 REPETE os elementos ([1,2]*2 = [1,2,1,2]); lista1 + lista2 CONCATENA (junta). Não é matemática.
b = a (lista) = MESMO objeto (mexe num, mexe no outro); b = a[:] = CÓPIA independente. Caiu na SEFA-PA 2026 — "altíssimo nível".
sum(dict) soma as CHAVES, não os valores.
🧊 GUARDE NO BOLSO (Bloco 1)
Delimitador: []=lista · {k:v}=dict · ()=tupla.
Índice começa em 0; negativo conta de trás; [i:f] para ANTES do f.
def define, for repete, indentação é lei.
🪤 sum(dict)=chaves · b=a[:]=cópia · lista*2=repete.
➡️ Próximo (Bloco 2): o NumPy — onde a operação matemática volta a funcionar "de verdade" (somar 3 a um array soma a cada elemento). É a ponte pro Pandas.
🎯 O que travar neste bloco (curtíssimo):
import numpy as np → np é o apelido.
np.array([...]) cria um array (matriz numérica).
Operação em array é ELEMENTO A ELEMENTO (array + 3 soma 3 a CADA um) — diferente da lista (que repetiria/concatenaria).
Dimensão = nº de [ no começo.
🟢 PROBABILIDADE PRO CE: BAIXA-MÉDIA. Mathias chama de "talvez o + cobrado depois de funções e repetição" em prova geral; no fiscal, entra mais como base do Pandas. Blindagem rápida.
A DABOA Comércio (a fictícia, sempre ela quando cheira fraude) declarou 4 valores de ICMS que precisam de um acréscimo fixo de R$ 100 de multa em cada. Com lista isso dá errado; com array NumPy funciona:
import numpy as np
valores = np.array([80000, 1500, 230000, 90])
valores + 100 # → array([80100, 1600, 230100, 190]) soma 100 em CADA umIsso é vetorização: a conta cai em cima de todos os elementos de uma vez, sem for. Com uma lista comum, lista + 100 daria erro, e lista * 2 repetiria a lista — por isso o Pandas/NumPy existem pra dados.
🧊 NumPy — o mínimo decorável
| Comando | O que faz |
|---|---|
np.array([1,2,3]) |
cria array 1D |
np.zeros((2,3)) / np.ones((2,3)) |
matriz 2×3 de 0 / de 1 |
np.arange(0, 10, 2) |
como range, aceita decimais → [0,2,4,6,8] |
np.linspace(0, 1, 5) |
n pontos igualmente espaçados — 🪤 INCLUI o último! (única exceção) |
.shape / .ndim / .size |
(linhas, colunas) / nº de dimensões / total de elementos |
arr[1:5] |
fatiamento (de novo: o 5 não entra) |
🧠 Macete de dimensão (Mathias): conte os colchetes [ no INÍCIO → [ = 1D, [[ = 2D, [[[ = 3D.
🪤 A pegadinha que decide: np.linspace INCLUI o fim — é a ÚNICA exceção à regra de ouro ("intervalo não inclui o fim"). np.linspace(0, 10, 5) = [0, 2.5, 5, 7.5, 10] (o 10 entrou!). Já np.arange(0, 10, 2) para no 8.
O PLACAR DOS PROFESSORES — NumPy
Leitura do Camilo: o Mathias é a única fonte e diz que NumPy "cai muito" — em prova geral. Nas 3 provas fiscais de 2026 (MT/GO/SP) o NumPy não caiu isolado; o que caiu foi Pandas (que usa NumPy por baixo). Então: NumPy é 🟢 blindagem de 10 min (reconhecer np.array, vetorização, dimensão pelos colchetes) e segue pro Pandas, que é onde o ponto mora.
⚖️ NOTA DE HONESTIDADE (anti-invenção): este bloco não traz questão FCC com badge porque, conferido no banco, não há questão de NumPy puro nas safras fiscais FCC de 2026. As de NumPy do guia do Mathias são de outras bancas (FGV/Cespe/Fundatec). Por isso é 🟢 blindagem — reconhece e segue. O ponto está no Pandas.
🧊 GUARDE NO BOLSO (Bloco 2): np.array cria array · operação é elemento a elemento (vetorização) · dimensão = nº de [ · np.linspace inclui o fim.
➡️ Próximo (Bloco 3): o CORAÇÃO da aula — o Pandas. É onde caíram as 5 questões de Pandas de MT (+ a de ETL que também é Pandas). Pega firme aqui.
🎯 O que travar neste bloco (é AQUI que decide):
DataFrame = a tabela do Pandas (uma planilha em código). Series = uma coluna.
groupby = agrupa por categoria e agrega (somar por município). pd.Grouper(freq='M') = agrupa por mês.
merge/join = cruza duas tabelas. how=: left (mantém a 1ª) · inner (só o que casa) · outer (tudo).
filtro booleano df[df["icms"] > 50000] = a malha fiscal em código.
🔴 PROBABILIDADE PRO CE: a MAIS ALTA do bloco órfão. Caiu 5× em MT 2026 (+ 1 de ETL feita em Pandas). Se a FCC trouxer Python no CE, vem como Pandas. É o alvo.
O Guilherme tem dois "arquivos" abertos na fiscalização da DABOA:
df_arrecadacao — arrecadação diária de ICMS, com coluna municipio e a data como índice. Milhares de linhas.
df_cadastro — o cadastro de contribuintes, indexado por CNPJ.
E ele precisa de três coisas que a FCC transforma em questão:
(a) o total mensal por município (sem misturar os meses) → isso é groupby + Grouper.
(b) cruzar os autos de infração com o cadastro, mantendo TODOS os autos (mesmo sem cadastro) → isso é left join.
(c) ver só quem passou de R$ 50 mil → isso é filtro booleano.
É exatamente o que MT cobrou. Vamos ler cada ferramenta.
🧊 DATAFRAME — a tabela do Pandas (a caixa-mãe)
import pandas as pd
# a tabela inteira uma coluna (Series)
df["municipio"] # acessa a coluna 'municipio'
df.loc["2026-01-15"] # loc = acessa por RÓTULO/nome do índice
df.iloc[0] # iloc = acessa por POSIÇÃO (i de inteiro: 0,1,2...)
df[df["icms"] > 50000] # FILTRO BOOLEANO: só as linhas com icms > 50 mil
| Conceito | É | Cara |
|---|---|---|
| DataFrame | a tabela toda (linhas × colunas) | uma planilha |
| Series | UMA coluna | uma lista com rótulo |
loc |
acessa por rótulo (nome) | df.loc["CE"] |
iloc |
acessa por posição (número) | df.iloc[0] = 1ª linha |
| filtro booleano | df[df[col] condição] |
a malha fiscal em código |
🧠 Macete: iloc = i de Inteiro (posição 0,1,2). loc = de Label (o nome/rótulo). Se viu número de posição → iloc; se viu nome → loc.
groupby + pd.Grouper(freq='M') ⭐ (o ponto-rei)groupby = "junta as linhas que têm o mesmo valor numa coluna e agrega" (soma, média, contagem). É o GROUP BY do SQL (Aula 03) em Pandas.
df.groupby("municipio")["icms"].sum() # total de ICMS POR municípioE quando você quer agrupar por mês mantendo o índice de data? Aí entra o pd.Grouper(freq='M') — ele agrupa pela frequência mensal ('M'=mês, 'D'=dia, 'Y'=ano):
# total mensal POR município E POR mês, ao mesmo tempo:
df.groupby(["municipio", pd.Grouper(freq="M")])["icms"].sum()🪤 A pegadinha-rei do Pandas (a ORDEM importa): a FCC troca a ordem das operações pra ver se você dorme. groupby().resample() ≠ resample().groupby() — fazer o errado primeiro mistura os meses ou ignora o município. E rolling('30D') aproxima o mês (janela de 30 dias corridos), enquanto pd.Grouper(freq='M') acerta o mês civil. "Aproximar" na alternativa = sinal de erro.
Em Python, utilizando a biblioteca Pandas, considere um DataFrame com arrecadação diária de ICMS, coluna municipio e índice datetime, e a necessidade de obter o total mensal por município sem perder granularidade temporal correta. Nesse caso, a operação que atende corretamente ao requisito apresentado é
merge / join (cruzar tabelas) ⭐ (o 2º ponto)Cruzar duas tabelas = o que o auditor faz o dia todo (NF-e × cadastro). Em SQL é o JOIN; em Pandas é merge (por coluna) ou join (por índice). O segredo é o how=:
🧊 OS TIPOS DE JOIN — how= (decore as 3 caixas)
how= |
O que mantém | Caso fiscal |
|---|---|---|
left |
TODAS as linhas da 1ª tabela (a da esquerda), case ou não | manter todos os autos mesmo sem cadastro ⭐ |
inner |
só o que casa nas duas (interseção) | só contribuintes que estão nos dois |
outer |
tudo das duas (união) | todos os autos e todos os cadastros |
right |
todas as da 2ª (a da direita) | (espelho do left) |
🔑 O bizu fiscal: "preservar TODOS os autos mesmo sem cadastro" → LEFT (autos é a tabela da esquerda; mantém todos). Quem manda na palavra é o "preservar todos de uma das tabelas".
Em Python, utilizando a biblioteca Pandas, uma fiscalização estadual cruza um DataFrame de autos de infração (df_autos) com outro de cadastro de contribuintes (df_cad), ambos indexados por CNPJ, e precisa preservar todos os autos mesmo sem cadastro correspondente. Nessa situação, a operação adequada é
Às vezes a FCC proíbe Pandas ("sem bibliotecas externas") e quer Python cru. O padrão é o dicionário acumulador: você cria um dict vazio e vai somando dentro dele, por chave, com um if filtrando.
total = {} # dicionário acumulador VAZIO
for registro in lista:
if registro["status"] == "VALIDO": # FILTRA: só os válidos
cnpj = registro["cnpj"]
total[cnpj] = total.get(cnpj, 0) + registro["valor_icms"] # ACUMULA por CNPJ Como ler: "para cada registro, se o status for VÁLIDO, soma o valor_icms na chave do CNPJ". O dict cresce conforme aparecem CNPJs novos. É o groupby na unha.
Uma SEFAZ recebe uma lista de dicionários Python com {cnpj, valor_icms, status} e precisa totalizar o ICMS por CNPJ, desconsiderando registros com status != "VALIDO", sem bibliotecas externas. Nesse caso, a abordagem mais adequada é
resample, pivot_table e apply (reconhecer o que são)Você não precisa escrever — precisa reconhecer na alternativa:
🧊 Mais ferramentas Pandas (só reconhecer)
| Comando | O que faz | Quando |
|---|---|---|
resample('M') |
reamostra série temporal por frequência (só funciona com índice de data) | total por mês/semana/ano |
pivot_table |
tabela dinâmica (linhas × colunas × valor agregado) — o "Tabela Dinâmica" do Excel | ICMS por município (linha) × mês (coluna) |
apply(função) |
aplica uma função em cada linha/coluna | transformar/calcular coluna nova |
merge vs concat |
merge cruza por chave (join) · concat empilha/cola |
cruzar ≠ empilhar |
🪤 Pegadinha: resample precisa de índice datetime — se a data virou string, ele quebra (foi a isca da letra A da questão do Grouper). E pivot_table ≠ merge: pivot resume uma tabela; merge junta duas.
O PLACAR DOS PROFESSORES — Pandas
Leitura do Camilo: aqui é onde o acervo é mais pobre e a prova foi mais rica — o abismo do tema. O Mathias trata Pandas no guia ("base operacional pra DataFrame/arrays"), mas mesmo ele não previu as de MT antes. A verdade nua: Pandas caiu 5× (+ 1 ETL feita em Pandas) e ninguém destilou. Por isso a estratégia é drill — você resolve as 6 reais (estão todas aqui) até reconhecer o padrão de olho fechado.
| Prof | Apostou Pandas? | Veredito | Observação |
|---|---|---|---|
| Felipe Mathias | ✅ (no guia) | 🎯 base certa | única fonte: "este Python é a base pra manipular DataFrame/arrays que a ciência de dados exige" |
| Lucas Ianni | ⚠️ tinha | ❌ furou | "não destilou o bloco Python/Pandas (Parte 5-6) que caiu pesado" — o maior buraco |
| Renato (CE) | ❌ | ❌ furou | empurrou "pra aula 2" — e a prova cobrou |
⚡ JÁ CAIU (fato, banco): na SEFAZ-MT 2026 caíram 5 de Python/Pandas — pd.Grouper (3863384), merge/join how (3863421), dict acumulador (3863414), gráfico de série temporal (3863424), boxplot de outliers (3863426) — + 1 de ETL feita em Pandas (3863430). Todas confirmadas no banco.
🔮 A APOSTA pro CE (NÃO aconteceu): o edital do CE não nomina Python, então pode não cair. Mas o risco assimétrico manda blindar: se cair, é ponto que o concorrente larga. Estudar é seguro barato; ignorar é apostar contra o que MT já mostrou.
🪤 AS 4 PEGADINHAS DE PANDAS QUE DECIDEM A QUESTÃO
A ORDEM das operações — groupby().resample() ≠ resample().groupby(). Fazer uma chave de cada vez troca o resultado. Duas chaves juntas = groupby([c1, c2]) ou pd.Grouper.
how= do join — left preserva todos da 1ª · inner corta (perde) · outer infla (traz órfão). Ache o "preservar todos de UMA tabela".
"Aproximar / forçar / converter em string" numa alternativa = confissão de erro (gambiarra que não cumpre o requisito exato).
sum(dict) soma as CHAVES · set descarta dado · max ≠ soma — clássicos do "Python puro".
🔗 CONEXÃO — não é ilha, liga com a Aula 04 (pré-processamento) e com SQL (Aula 03)
O pré-processamento que você viu na Aula 04 (limpar CNPJ com regex, tratar 12% de faltantes, padronizar datas dos 2,3 milhões de declarações de SP) é executado em Pandas — esse df é o mesmo. Python é o braço do pré-processamento.
groupby do Pandas = GROUP BY do SQL (Aula 03). merge how=left = LEFT JOIN do SQL. É a MESMA lógica de cruzar/agregar tabelas, em duas linguagens. Quem entende o JOIN do SQL já entende o merge do Pandas — e vice-versa.
Bordão da ponte: "o GROUP BY que eu escrevo em SQL é o groupby que eu leio em Pandas; o JOIN é o merge."
🧊 GUARDE NO BOLSO (Bloco 3 — o coração)
DataFrame = tabela · loc = por rótulo · iloc = por posição (i de inteiro) · filtro df[df[col]>x].
groupby([municipio, pd.Grouper(freq='M')]) = agrupa por município E mês (duas chaves juntas).
merge/join how: left preserva a 1ª · inner corta · outer infla.
dict acumulador = groupby na unha (if filtra + soma na chave).
🪤 ordem das ops importa · "aproximar/forçar" = erro · sum(dict)=chaves.
➡️ Próximo (Bloco 4): a visualização — qual gráfico pra quê. Curto: linha = série temporal, boxplot = outliers. Caiu 2× em MT.
🎯 O que travar neste bloco (3 gráficos, sem decoreba):
Gráfico de LINHA → série temporal (evolução no tempo: arrecadação mês a mês).
BOXPLOT → outliers + distribuição (compara quartis, acha o valor fora da curva).
HISTOGRAMA → distribuição/frequência de UMA variável.
🟡 PROBABILIDADE PRO CE: MÉDIA. Caiu 2× em MT (linha e boxplot). É reconhecimento simples — qual gráfico serve pra qual objetivo.
O Guilherme precisa de dois gráficos pro relatório da SEFAZ:
A evolução mensal da arrecadação (jan → dez): é uma linha no tempo → gráfico de linha.
Comparar os valores de autos de infração por tipo de tributo e achar os fora da curva (o auto absurdamente alto): é distribuição + outliers → boxplot. Esse boxplot vira anexo do processo que a juíza Bia analisa pra entender por que um auto destoou tanto dos demais.
🧊 QUAL GRÁFICO PRA QUÊ (decore o objetivo → gráfico)
| Objetivo | Gráfico | Sinal no enunciado |
|---|---|---|
| evolução no TEMPO | linha (line) | "evolução mensal", "série temporal", "ao longo do tempo" |
| achar OUTLIERS / comparar distribuições | boxplot | "outliers", "assimetria", "quartis", "valores fora da curva" |
| distribuição/frequência de 1 variável | histograma | "distribuição de frequências", "faixas" |
| proporção de um todo | pizza / barra | "participação", "% do total" |
🔑 Os 2 bizus que caíram: série temporal = LINHA (com título e rótulos de eixo via Matplotlib: set_title, set_xlabel, set_ylabel). outlier = BOXPLOT (a "caixa" mostra os quartis; os pontos soltos fora dos "bigodes" são os outliers).
Em Python, utilizando bibliotecas de visualização de dados, uma SEFAZ precisa comunicar a evolução mensal de arrecadação (índice temporal) em relatório institucional, com título e rótulos explícitos de eixos. Nesse caso, o tipo de gráfico e a prática que atendem corretamente ao requisito apresentado é usar
Em Python, utilizando bibliotecas de visualização de dados, um setor de fiscalização compara valores de autos de infração por tipo de tributo para identificar assimetria e possíveis outliers de forma padronizada. Nesse caso, a técnica de visualização que atende corretamente ao requisito apresentado é:
O PLACAR DOS PROFESSORES — Visualização
Leitura do Camilo: visualização é reconhecimento puro — qual gráfico serve pra qual objetivo. Caiu 2× em MT (linha e boxplot) e, de novo, órfão nos cursinhos. Mas é o mais fácil do bloco: você decora 3 pares (tempo→linha, outlier→boxplot, distribuição→histograma) e resolve. 🟡 blindagem média — 10 min, alto retorno se cair.
🪤 Pegadinha de visualização: a FCC adora oferecer o gráfico quase certo com o motivo errado ("barras de médias detectam outliers" — não detectam) ou trocar distribuição (boxplot/histograma) por tendência (linha). Ancore no objetivo do enunciado, não no gráfico bonito.
🧊 GUARDE NO BOLSO (Bloco 4): tempo → LINHA · outlier → BOXPLOT · distribuição → HISTOGRAMA. Título/eixos no Matplotlib = set_title/set_xlabel/set_ylabel. Média NÃO acha outlier.
➡️ Próximo (Bloco 5): o método de ler código na prova + o drill final das 6 questões reais de MT (5 Pandas + 1 ETL em Pandas) e uma de GO de bônus, com a honestidade na mesa.
🎯 O que travar neste bloco:
O método de tradução linha a linha (código → português).
Pandas no ETL — o "transformar" do pré-processamento é feito em Pandas (conecta Aula 02 e 04).
🔴 É a síntese: transforma tudo dos blocos anteriores em reflexo de prova.
Lê o REQUISITO primeiro (a frase "preciso de X sem perder Y"). Sublinha os verbos (totalizar, preservar, agrupar, comparar).
Traduz cada alternativa pra português — não "executa" mentalmente, só diz o que a operação FAZ ("isso é um inner join", "isso soma tudo sem filtrar").
Caça o erro plantado — cada distrator tem um: ordem trocada, operação errada, "aproximar/forçar", filtro ausente, ferramenta errada.
Bate com os verbos — a certa cumpre TODOS os verbos do requisito; a errada falha em pelo menos um.
Marca e segue — não fica refinando. Achou a com um erro? Risca. Sobrou uma limpa? É ela.
🔑 O bizu do Pacheco (resolução SP), válido pra Python: "esse tipo de questão não é pra você sair julgando tudo: achou o que não tem a ver, risca e vai embora." Eliminação > certeza.
A Aula 02 te deu o ETL (Extract → Transform → Load). Pois o T (transformar) — padronizar datas, normalizar códigos, agregar valores — é feito em Pandas. A FCC cobrou isso direto:
Considerando um pipeline diário que consolida arquivos CSV/JSON de sistemas legados para relatórios de arrecadação e que utiliza Pandas para padronizar datas, normalizar códigos e agregar valores, a etapa que caracteriza corretamente a transformação no processo ETL é
⚠️ Honestidade: esta é mais Machine Learning (Aula 04) do que Pandas, mas mostra que a FCC escala o Python pra bibliotecas avançadas. Caiu em GO (o espelho do CE). Não é alvo — é um aviso de teto.
Considerando uma equipe de ciência de dados da Secretaria da Economia Estadual que prototipa redes neurais em Python e precisa depurar o fluxo de gradientes durante experimentos com dados fiscais, ajustando dinamicamente o caminho computacional conforme condições em tempo de execução, a característica do PyTorch que atende diretamente ao cenário descrito é
🧊 GUARDE NO BOLSO (Bloco 5)
Método: requisito → traduz alternativa → caça o erro plantado → bate com os verbos → marca e segue.
ETL: Extrair (E) → Transformar (T = Pandas: padronizar/normalizar/agregar) → Load (L).
🔮 PyTorch = grafo dinâmico (define-by-run) — só se a FCC subir o nível; estuda por último.
Para tudo e respira, Felício. 🫁 Você acabou de fazer o que quase nenhum concorrente vai fazer: olhou Python na cara e aprendeu a ler código. Não virou programador — virou leitor de Pandas, que é tudo que a FCC pede. Guarda o essencial e leva o plano.
Os 4 bizus que decidem as questões de Pandas:
Tema 🔑 Bizu colável Caso fiscal groupby + Grouper duas chaves juntas = groupby([municipio, pd.Grouper(freq='M')])total mensal por município merge/join how left preserva a 1ª · inner corta · outer infla preservar TODOS os autos = LEFT dict acumulador iffiltra + soma na chave (groupby na unha)totalizar ICMS por CNPJ só VÁLIDO visualização tempo→LINHA · outlier→BOXPLOT · distribuição→HISTOGRAMA relatório de arrecadação
E as pegadinhas universais (do guia do Mathias):
🪤 Intervalo não inclui o fim (range, slice) — exceto np.linspace.
🪤 A ORDEM das operações Pandas importa — groupby().resample() ≠ resample().groupby().
🪤 "Aproximar / forçar / converter em string" numa alternativa = confissão de erro.
🪤 sum(dict) soma as CHAVES · set descarta dado · a média NÃO acha outlier.
⚖️ Lembre da honestidade: o edital do CE não nomina Python — isto é hedge. Então estude DEPOIS do ouro (SQL, ML, arquitetura), e estude enxuto:
1️⃣ DRILL das 6 questões de MT (~40 min) — o ROI máximo do tema.
2️⃣ Decora os 4 bizus (~15 min) — a tabela acima.
groupby+Grouper · how= (left/inner/outer) · dict acumulador · gráfico→objetivo. São os 4 padrões que MT repetiu.3️⃣ Blindagem de sintaxe/NumPy (~10 min) — só pra não travar na leitura.
sum(dict)=chaves · vetorização do array · np.linspace inclui o fim.🧭 Bordão do plano: Python é seguro de 1h — não é a vaga, é a apólice. Mas é a apólice que o concorrente esqueceu de pagar.
Honestidade temporal: o CE ainda NÃO aconteceu (prova 01-02/08/2026). Tudo de Python é aposta 🔮 calibrada pelo que JÁ CAIU ✅ em MT (5q Python/Pandas + 1 ETL em Pandas) e GO (1q de PyTorch).
Tema Caiu (fato) Pro CE Pandas (groupby/Grouper/merge/dict) ✅ MT 5q + 1 ETL (banco) 🔮 hedge ALTO (se cair, ponto órfão) Visualização (linha/boxplot) ✅ MT 2q (banco) 🔮 hedge médio PyTorch / ML lib ✅ GO 1q (banco) 🔮 borda — só com base de ML NumPy / sintaxe ❌ não isolado (fiscal) 🟢 pré-requisito
O professor de TI aqui é o Camilo. O Mathias deu a base (o único que deu), mas ninguém previu as de MT. A palavra final é nossa: Python é o ponto que o edital não promete, mas que MT entregou — e que TODO concorrente larga. Você não decora cursinho; você lê o código e deduz o que faz. Onde todos estão cegos, quem enxerga um pouco já passa na frente.
🔑 Bordão-mestre da Aula 07: na FCC, Python não se escreve — se LÊ. Traduz pra português, caça o erro plantado, marca o que cumpre o requisito. ⚡
🧭 PRÓXIMA PARADA — o ouro de verdade. Você fechou a apólice de seguro (Python). Agora volta pro cofre: Aula 02 (Arquitetura: Data Lake × Warehouse × Lakehouse, ETL×ELT), Aula 03 (SQL na mão) e Aula 04 (Machine Learning — o OURO MÁXIMO, 7 de 11 em SP). Lembra: o
groupbyque você leu aqui é o GROUP BY que você vai escrever em SQL. Te espero lá. 🪜
🔵 Bate o olho e resolve lendo cada alternativa traduzida pra português · 🔴 Corrige com calma as que travar. Todas FCC 2026, conferidas no banco. As 6 primeiras são o alvo (Pandas de MT — o que crava); a última (PyTorch/GO) é teto de dificuldade, só pra sentir até onde a banca pode subir.
Última atualização: 22/06/2026 22:12 — Camilo