Pandas & NumPy Academy · Aula

Operações vetorizadas em Series

Realize operações aritméticas entre duas Series, trate automaticamente o alinhamento de índices e preencha com NaN os valores alinhados ausentes.

Aula 3 de 413 etapas

Operações vetorizadas em Series é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

Por que usar operações vetorizadas?

Assim como o NumPy, as Series do Pandas oferecem operações vetorizadas que aplicam operações aritméticas, comparações e funções a todos os elementos sem ciclos do Python. Isso proporciona concisão e velocidade. Internamente, cada operação delega o trabalho a rotinas em nível C do NumPy, mas o Pandas acrescenta um benefício fundamental: alinhamento automático dos índices antes de executar a operação.

import pandas as pd

revenue = pd.Series([1000, 2000, 1500], index=['Jan', 'Feb', 'Mar'])
tax_rate = 0.2
net = revenue * (1 - tax_rate)   # vectorized -- no loop
print(net)

Aritmética entre duas Series

Quando você soma, subtrai, multiplica ou divide duas Series, o Pandas primeiro as alinha pelos rótulos do índice. Apenas as posições em que ambas as Series têm um rótulo produzem um resultado; rótulos sem correspondência produzem NaN. Esse comportamento evita erros ocultos causados por dados desalinhados — por exemplo, ao somar valores de janeiro provenientes de duas fontes de dados armazenadas em ordens diferentes.

import pandas as pd

a = pd.Series([10, 20, 30], index=['x', 'y', 'z'])
b = pd.Series([1, 2, 3], index=['y', 'z', 'w'])

print(a + b)
# w     NaN
# x     NaN
# y    21.0
# z    32.0

Preenchendo NaN em operações alinhadas

Para evitar a propagação de NaN em operações com dados desalinhados, use os métodos aritméticos, como .add(), .sub(), .mul() e .div(), com o parâmetro fill_value=. Isso substitui por um valor fornecido qualquer rótulo ausente em uma das Series antes de executar a operação — normalmente 0 para adição e 1 para multiplicação.

import pandas as pd

a = pd.Series([10, 20, 30], index=['x', 'y', 'z'])
b = pd.Series([1, 2, 3], index=['y', 'z', 'w'])

result = a.add(b, fill_value=0)
print(result)
# w     3.0
# x    10.0
# y    21.0
# z    32.0

Aritmética escalar em uma Series

A aritmética com um escalar aplica a operação a todos os elementos e produz uma nova Series com o mesmo índice. Essa é a forma mais simples de vetorização: s + 5, s * 100, s ** 2. A aritmética escalar nunca introduz NaN e é usada para conversão de unidades, normalização e aplicação de deslocamentos em séries temporais.

import pandas as pd

prices_eur = pd.Series([1.0, 2.5, 4.0], index=['a', 'b', 'c'])
exchange = 1.08
prices_usd = prices_eur * exchange
print(prices_usd.round(2))
# a    1.08
# b    2.70
# c    4.32

Aplicando ufuncs do NumPy a Series

As ufuncs do NumPy funcionam perfeitamente em Series do Pandas e retornam uma Series com o mesmo índice. Isso significa que você pode chamar diretamente np.sqrt(s), np.log1p(s) ou np.exp(s) em uma Series, sem convertê-la primeiro em uma matriz. O resultado é uma nova Series que preserva os rótulos originais.

import pandas as pd
import numpy as np

s = pd.Series([0, 1, 4, 9, 16], index=list('abcde'))
print(np.sqrt(s))
# a    0.0
# b    1.0
# c    2.0
# d    3.0
# e    4.0

Operações de comparação em Series

Os operadores de comparação (==, !=, >, <, >=, <=) retornam uma Series booleana elemento a elemento. Eles são a base da filtragem: você passa a Series booleana para .loc para selecionar as linhas correspondentes. O Pandas também alinha pelo índice ao comparar duas Series.

import pandas as pd

s = pd.Series([3, 7, 2, 9, 1], index=list('abcde'))
print(s > 4)
# a    False
# b     True
# c    False
# d     True
# e    False
print(s[s > 4])  # b:7  d:9

Encadeando operações vetorizadas

Como cada operação retorna uma nova Series, você pode encadear várias transformações em uma única expressão. Isso torna o código legível e evita a criação de variáveis intermediárias desnecessárias. Em pipelines complexos, divida o encadeamento em várias linhas usando parênteses. O encadeamento é o equivalente, no Pandas, à programação funcional com dados imutáveis.

import pandas as pd
import numpy as np

raw_scores = pd.Series([55, 80, 45, 90, 72])
normalised = (raw_scores - raw_scores.min()) / (raw_scores.max() - raw_scores.min())
print(normalised.round(2))
# 0    0.22
# 1    0.78
# 2    0.00
# 3    1.00
# 4    0.60

Tratando NaN em operações vetorizadas

NaN é contagioso: qualquer operação aritmética que envolva NaN produz NaN. Use s.fillna(value) para substituí-lo antes da operação ou use o parâmetro skipna=True nos métodos de agregação. A função pd.isna(s) retorna uma Series booleana que marca as posições com NaN — use-a para verificar os dados antes de calcular estatísticas.

import pandas as pd
import numpy as np

s = pd.Series([1.0, np.nan, 3.0, np.nan, 5.0])
print(s + 10)
# 0    11.0  2    13.0  4    15.0 -- NaN stays NaN

print(s.fillna(0) + 10)
# 0    11.0  1    10.0  2    13.0  3    10.0  4    15.0

abs(), clip() e round() em Series

As Series do Pandas disponibilizam diretamente muitos métodos semelhantes aos do NumPy: s.abs(), s.clip(lower, upper) e s.round(decimals) retornam novas Series com a transformação aplicada elemento a elemento. Eles equivalem às chamadas de ufuncs do NumPy, mas usam a sintaxe de método e preservam o índice e o nome da Series.

import pandas as pd

s = pd.Series([-2.5, 1.3, -0.7, 4.9, -3.1])
print(s.abs())          # [2.5 1.3 0.7 4.9 3.1]
print(s.clip(-2, 2))    # [-2.  1.3 -0.7  2. -2. ]
print(s.round(0))       # [-2.  1.  -1.   5.  -3.]

pct_change() para taxas de crescimento

s.pct_change() calcula a variação percentual entre elementos consecutivos: (atual - anterior) / anterior. O primeiro elemento é NaN, pois não há um valor anterior. Essa é a operação padrão para calcular taxas de crescimento mês a mês, retornos diários em finanças e características de variação para modelos de séries temporais.

import pandas as pd

monthly_revenue = pd.Series([100, 120, 110, 140],
                            index=['Q1', 'Q2', 'Q3', 'Q4'])
growth = monthly_revenue.pct_change()
print(growth.round(3))
# Q1      NaN
# Q2    0.200
# Q3   -0.083
# Q4    0.273

cumsum() e cumprod() em Series

s.cumsum() retorna uma Series de totais acumulados, e s.cumprod() retorna produtos acumulados. Eles são usados para calcular receita acumulada, retornos compostos de investimentos ou contagens acumuladas de palavras. Os rótulos do índice original são preservados, facilitando a representação da série acumulada ao longo do tempo ou por categoria.

import pandas as pd

daily_sales = pd.Series([100, 150, 80, 200],
                        index=['Mon', 'Tue', 'Wed', 'Thu'])
print(daily_sales.cumsum())
# Mon    100
# Tue    250
# Wed    330
# Thu    530

Verificação rápida

Teste sua compreensão das operações vetorizadas em Series apresentadas nesta lição.

Recapitulação da lição

Nesta lição, você aprendeu que: os operadores aritméticos se aplicam elemento a elemento às Series, sem ciclos; o Pandas alinha automaticamente duas Series pelo rótulo do índice antes da operação, colocando NaN nas posições sem correspondência; e métodos como fill_value, pct_change e cumsum ampliam as operações vetorizadas para tarefas analíticas. Em seguida, exploraremos métodos úteis de Series, como describe, value_counts e map, para obter resumos rapidamente.

Grátis para começar

Aprenda Python com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
30
Aulas
120

Perguntas Frequentes

A aula “Operações vetorizadas em Series” é grátis?

Sim — o texto completo de “Operações vetorizadas em Series” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

O que vou aprender em “Operações vetorizadas em Series”?

Realize operações aritméticas entre duas Series, trate automaticamente o alinhamento de índices e preencha com NaN os valores alinhados ausentes. Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Pandas & NumPy Academy?

Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Operações vetorizadas em Series”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Pandas & NumPy Academy?

Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Criando uma Series
  2. Acesso por rótulo e por posição
  3. Operações vetorizadas em Series
  4. Métodos úteis de Series
← Voltar para Pandas & NumPy Academy