Series e DataFrames no pandas: primeiros passos

Uma Series mantém uma sequência de valores junto com rótulos. Esses rótulos dão significado aos valores: uma medição de chuva pertence a um dia, e uma população pertence a uma cidade. Importe pandas e NumPy usando seus nomes curtos habituais.

import pandas as pd
import numpy as np
rain = pd.Series([4.5, 3.0, 6.2],
                 index=["Mon", "Tue", "Wed"], name="rain_mm")

Ler valores e rótulos

Os valores são 4,5; 3,0 e 6,2; o índice é Mon, Tue e Wed. Sem index=, o pandas fornece os rótulos 0, 1 e 2. Um dicionário fornece ambos de uma vez: pd.Series({"Lima": 10, "Oslo": 5, "Pune": 7}) obtém seus rótulos das chaves, na ordem do dicionário.

Atributos descrevem a Series sem parênteses: rain.index contém os rótulos, rain.dtype é float64, rain.name é "rain_mm" e rain.size é 3. Use rain.to_numpy() quando precisar de um array do NumPy. O atributo mais antigo .values retorna tipos diferentes de array para tipos de dados diferentes; dados de texto podem produzir um array do pandas.

Um tipo de dados informa ao pandas que tipo de valores ele armazena. Tipos comuns são int64 para números inteiros, float64 para decimais, bool para True/False, str para texto e datetime64 para datas e horas. O pandas 3 infere texto como str; exemplos antigos frequentemente exibem object.

Trabalhar com a Series inteira

Para s = pd.Series([10, 20, 30], index=["a", "b", "c"]), s * 2 produz os valores 20, 40 e 60. s > 15 produz False, True e True. Ambos mantêm os rótulos. Essas operações são vetorizadas: uma expressão opera sobre a Series inteira sem um laço Python.

Consulte um rótulo com s["b"], que produz 20. Consulte uma posição com s.iloc[0], que produz 10. A expressão "b" in s verifica o índice; 20 in s é False. Mesmo um inteiro entre colchetes é um rótulo: com o índice [2, 0, 1], s[0] significa o rótulo 0, não a primeira entrada. Com rótulos de texto, s[0] gera KeyError no pandas 3.

Associar rótulos na aritmética

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

O rótulo compartilhado y combina 2 e 10 para produzir 12,0; z combina 3 e 20 para produzir 23,0. Os rótulos w e x aparecem em apenas uma entrada, então recebem NaN. O resultado inclui os quatro rótulos. Somar pela posição visual das linhas produziria incorretamente 11, 22 e 33.

Use a.add(b, fill_value=0) quando um valor ausente deve contar como zero. Seus resultados são w 30,0, x 1,0, y 12,0 e z 23,0. Métodos relacionados incluem sub, mul e div.

Reconhecer valores ausentes

Um valor ausente de ponto flutuante ou str usa NaN; uma data ou hora ausente usa NaT; um inteiro ausente em um tipo com suporte a valores ausentes usa <NA>. pd.Series([1, None, 3]) se torna float64, exibindo 1,0, NaN e 3,0, porque o tipo comum int64 não pode armazenar NaN.

Um DataFrame é uma tabela bidimensional. Cada linha registra uma observação, como um pedido; cada coluna contém uma variável, como uma quantidade. As colunas podem ter tipos de dados diferentes, mas compartilham o mesmo índice de linhas.

Construir uma tabela a partir de dados Python

df = pd.DataFrame({
    "product": ["Notebook", "Desk lamp", "Pen set", "Mug"],
    "quantity": [3, 1, 2, 4],
    "unit_price": [2.50, 18.00, 4.75, 6.00]
})

Cada chave do dicionário se torna um nome de coluna; cada lista fornece os valores dessa coluna. As listas devem ter o mesmo comprimento para que cada linha tenha um lugar em cada coluna. Aqui os rótulos do índice vão de 0 a 3. Listas de comprimentos diferentes geram um ValueError.

Uma lista de dicionários, por sua vez, fornece um dicionário por linha. pd.DataFrame([{"a": 1, "b": 2}, {"a": 3, "c": 4}]) cria as colunas a, b e c. O b ausente na segunda linha e o c ausente na primeira se tornam NaN, então essas colunas usam float64. Um array bidimensional do NumPy também pode fornecer valores, com columns=[...] nomeando as colunas.

Ler as dimensões da tabela

df.shape é (4, 3): quatro linhas e três colunas, nessa ordem. len(df) é 4, enquanto df.size é 12 porque conta células. df.index contém rótulos de linhas, df.columns contém rótulos de colunas e df.dtypes fornece um tipo de dados por coluna. Esses são atributos: df.shape() tenta chamar uma tupla e gera TypeError. df.T troca linhas por colunas.

Manter uma Series ou uma tabela

A lista interna solicita uma coleção de colunas. Sem ela, df["product", "unit_price"] fornece uma única chave em forma de tupla, que não corresponde a nenhum dos nomes comuns de coluna e gera KeyError.

Colchetes também funcionam quando os nomes contêm espaços ou entram em conflito com métodos. A notação com ponto, como df.quantity, só funciona para nomes adequados. Uma coluna chamada size precisa de df["size"], porque df.size significa o número de células da tabela. Crie colunas também com colchetes: df["total"] = 5 adiciona uma coluna, enquanto df.total = 5 não adiciona.

Escolher um eixo

Para numbers = pd.DataFrame({"a": [1, 2], "b": [3, 4]}), numbers.sum() soma ao longo das linhas, produzindo a 3 e b 7. Esse é o axis=0, também chamado de "index". numbers.sum(axis=1) soma ao longo de cada linha, produzindo 4 e 6; esse eixo também é chamado de "columns". Identifique primeiro o resultado necessário: um total por coluna ou um total por linha.

Extrair uma linha cria uma Series cujos rótulos são os nomes das colunas. Essa Series precisa de um tipo de dados capaz de armazenar todas as células da linha. Uma linha que mistura inteiros e números de ponto flutuante se torna float64; uma linha que mistura texto e números se torna object. As colunas originais mantêm seus tipos separados.

Rótulos de linhas podem ter significado, como um número de pedido, ou apenas identificar as linhas atuais. Escolher um índice útil facilita a interpretação de consultas e resultados posteriores. Alterar rótulos retorna uma nova tabela, então mantenha o resultado com uma atribuição.

Mover um identificador para o índice

orders = pd.DataFrame({
    "order_id": [1001, 1002, 1003],
    "product": ["Notebook", "Desk lamp", "Pen set"],
    "unit_price": [2.50, 18.00, 4.75]
})
orders_by_id = orders.set_index("order_id")

A tabela original tem um RangeIndex padrão: 0, 1 e 2. A nova tabela tem os rótulos 1001, 1002 e 1003. order_id saiu das colunas e passou para o índice. orders_by_id.loc[1002] agora identifica a linha de Desk lamp pelo identificador.

Chamar orders.set_index("order_id") sem salvar o resultado deixa orders inalterado. Uma reatribuição, como orders = orders.set_index("order_id"), mantém a nova estrutura. No pandas 3.1, inplace= está obsoleto para esses métodos de alteração de rótulos e para ordenação; use atribuição.

Mover rótulos de volta para uma coluna

orders_by_id.reset_index() restaura order_id como uma coluna comum e fornece um novo RangeIndex. Um índice sem nome se torna uma coluna chamada index. Isso preserva a identidade antiga das linhas.

reset_index(drop=True) descarta os rótulos antigos. Para um índice [10, 20, 30], reset_index() mantém esses números em uma coluna index; reset_index(drop=True) os perde e usa 0, 1 e 2. Após filtrar ou ordenar, decida se os rótulos antigos são úteis antes de descartá-los. Renumerar o índice não altera os valores dos dados nem desfaz uma ordenação.

Renomear ou remover rótulos

renamed = orders.rename(columns={"unit_price": "price"})
short = orders.drop(columns=["product"])
remaining = orders.drop(index=[0, 1])

rename associa rótulos antigos a novos e mantém os nomes não listados. Por padrão, um nome antigo escrito incorretamente é ignorado, então inspecione .columns se uma renomeação parecer não ter feito nada. Para substituir todos os nomes de colunas, atribua uma lista completa a orders.columns; seu comprimento deve corresponder ao número de colunas.

drop(columns=...) remove colunas; drop(index=...) remove linhas por rótulo. Um rótulo ausente gera KeyError. Após ordenar, o rótulo 0 pode não estar mais na primeira linha: removê-lo ainda remove a linha com rótulo 0.

Selecione uma lista para escolher a ordem das colunas: orders = orders[["order_id", "unit_price", "product"]]. Colunas ausentes dessa lista são removidas do resultado.

Verificar se um identificador realmente identifica uma linha

Rótulos de índice podem se repetir. Verifique orders_by_id.index.is_unique antes de tratá-los como identificadores únicos. Se o rótulo 1002 ocorrer duas vezes, .loc[1002] retornará ambas as linhas como um DataFrame. Com rótulos únicos, a mesma consulta por um único rótulo retorna uma Series.

Um índice significativo também melhora os resumos. Em uma tabela meteorológica indexada por dia, weather["temp_c"].idxmax() informa um dia como "Thu"; com um índice padrão, informa um número de linha.

Um CSV armazena uma tabela como texto: registros ocupam linhas e um delimitador separa os campos. A primeira linha frequentemente contém nomes de colunas. Carregar o arquivo corretamente exige identificar tanto sua estrutura quanto o significado de seus valores.

Carregar a tabela de pedidos

orders = pd.read_csv("orders.csv")

Um caminho relativo é resolvido a partir do diretório de trabalho atual do Python. Uma localização incorreta gera FileNotFoundError. Um caminho absoluto ou uma URL também pode ser passado a read_csv.

Os exemplos usam este arquivo. A última linha tem um campo de quantidade vazio.

order_id,date,product,category,quantity,unit_price
1001,2026-03-02,Notebook,Stationery,3,2.50
1002,2026-03-02,Desk lamp,Home,1,18.00
1003,2026-03-03,Pen set,Stationery,2,4.75
1004,2026-03-04,Mug,Home,4,6.00
1005,2026-03-04,Backpack,Bags,1,35.00
1006,2026-03-05,Notebook,Stationery,,2.50

Com as opções padrão, o resultado tem forma (6, 6) e rótulos de índice de 0 a 5. O pandas infere os tipos: order_id é int64, unit_price é float64 e quantity também se torna float64 porque seu campo em branco se torna NaN. As outras colunas, incluindo date, são str. Uma string que parece uma data ainda é texto até ser interpretada.

Ajustar à estrutura do arquivo

Para um arquivo cujas linhas são a;b, 1,5;2 e 3,0;4, use pd.read_csv("file.csv", sep=";", decimal=","). A coluna a contém então 1,5 e 3,0. Usar a vírgula como separador padrão produz uma coluna chamada a;b, um sinal para verificar o delimitador.

index_col="order_id" transforma essa coluna no índice de linhas durante o carregamento. thousands="," lê um campo como "1,200" como 1200; em um arquivo separado por vírgulas, o campo precisa estar entre aspas conforme as regras do CSV para que sua vírgula interna não seja outro delimitador.

Preservar o significado ao inferir tipos

Códigos como "001" são identificadores, não quantidades. dtype={"id": str} preserva seus zeros à esquerda. Se o pandas primeiro os converter para 1, converter esse número de volta para texto não consegue recuperar quantos zeros o arquivo continha.

Campos vazios e marcadores comuns como NA, N/A, NULL, NaN e None são ausentes por padrão. Adicione um marcador específico do arquivo com na_values=["-"]. Essas são regras de carregamento, então verifique as convenções do arquivo quando um código parecer um marcador de valor ausente.

Use parse_dates=["date"] para ler as datas do exemplo como valores de data e hora. No pandas 3, essas datas usam resolução de microssegundos, datetime64[us]. UTF-8 é a codificação de texto padrão. Um UnicodeDecodeError exige verificar a codificação do arquivo e fornecer a opção correspondente, como encoding="latin-1".

Uma leitura bem-sucedida significa que o pandas conseguiu interpretar o arquivo. Isso não estabelece que as colunas, os tipos e os valores ausentes correspondam ao que a tabela deve representar. Inspecione o novo DataFrame antes de fazer cálculos com ele.

Verificar linhas visíveis e dimensões

orders.head(3)
orders.tail()
orders.shape
orders.columns.tolist()

head() mostra cinco linhas por padrão; head(3) mostra três. tail() verifica o fim, onde uma exportação pode conter registros diferentes. sample(3, random_state=0) fornece uma amostra aleatória reproduzível de três linhas. Em um caderno computacional, a expressão final de uma célula é exibida automaticamente; em outros ambientes, use print.

O arquivo de pedidos deve conter seis linhas e seis colunas. Uma prévia deve mostrar colunas nomeadas e o primeiro pedido como dado. Se o primeiro registro aparecer entre os nomes das colunas, o arquivo provavelmente não tem cabeçalho e precisa de header=None. Se tudo ocupar uma única coluna larga, verifique sep.

Os nomes das colunas devem corresponder exatamente, incluindo maiúsculas, minúsculas e espaços. orders["Product"] falha quando o nome é product. Inspecionar a lista facilita a identificação de espaços no fim. orders.columns = orders.columns.str.strip() remove espaços das extremidades dos nomes do cabeçalho.

Ler a estrutura com info

orders.info() exibe o intervalo do índice, o nome de cada coluna, a contagem de valores presentes, o tipo de dados e o uso de memória. No exemplo de seis linhas, quantity tem cinco valores não nulos; as outras colunas têm seis cada. Os tipos são duas colunas de ponto flutuante, uma coluna inteira e três colunas str. orders.dtypes fornece uma lista compacta dos tipos.

Uma coluna aparentemente numérica com tipo str merece inspeção: um valor como "unknown", uma unidade como "12 kg" ou um separador de milhares não tratado pode impedir a inferência numérica. Datas também permanecem como texto, a menos que sejam interpretadas. Decida o tipo necessário pelo significado da coluna, não apenas por sua aparência em uma prévia.

Contar lacunas e valores repetidos

orders.isna().sum()
orders.isna().any(axis=1).sum()
orders.nunique()

isna() cria uma tabela booleana: True marca uma célula ausente. Somar ao longo de cada coluna conta essas células. Quantity tem um valor ausente e todas as outras colunas têm zero. Para contar as linhas afetadas, .any(axis=1) primeiro verifica se cada linha tem alguma lacuna, depois .sum() conta essas linhas. Somar todas as contagens das colunas poderia contar uma linha várias vezes.

nunique() conta valores presentes distintos: os pedidos têm seis identificadores, quatro datas, cinco produtos, três categorias, quatro quantidades e cinco preços. Compare a contagem de identificadores com a contagem de linhas para verificar a unicidade, junto com a contagem de identificadores ausentes. orders.duplicated(subset="product") marca a segunda linha com Notebook, de rótulo 5, como repetida. Um produto repetido é legítimo aqui; um identificador de pedido repetido exigiria investigação.

Ler uma visão geral numérica rápida

orders.describe() apresenta contagem, média, desvio padrão, mínimo, quartis e máximo para colunas numéricas. A contagem de quantity é cinco, então sua média resume cinco quantidades registradas. Verifique intervalos e unidades plausíveis, além dos tipos: uma coluna pode ser numérica e ainda conter um erro de entrada. Mantenha juntos a contagem observada de linhas e colunas, os tipos, as contagens de valores ausentes e a verificação de identificadores ao revisar um novo carregamento.

O tipo de dados de uma coluna determina quais operações fazem sentido. Uma coluna de texto contendo "12" ainda armazena texto; não é possível calcular sua média como a de uma coluna numérica. Converta deliberadamente e atribua o resultado de volta à tabela.

Escolher conversão estrita ou coerção

astype converte uma Series para um tipo especificado, como int, float, str ou "Int64". A conversão falha quando um valor não pode ser representado no tipo solicitado.

raw = pd.Series(["12", "7", "n/a", "3.5"])
numeric = pd.to_numeric(raw, errors="coerce")

raw.astype(float) gera ValueError em "n/a". Com errors="coerce", os valores de saída são 12,0; 7,0; NaN e 3,5. O valor que falhou se torna ausente em vez de interromper a conversão. Compare raw.isna().sum() com numeric.isna().sum(): zero valores ausentes passaram a ser um, identificando um valor que precisa de verificação.

A coerção é uma política de conversão, não uma evidência de que toda nova lacuna seja inofensiva. Use as contagens anteriores e posteriores para encontrar perdas. Armazene a conversão em uma nova variável ou coluna quando o texto bruto for útil para rastrear um valor cuja conversão falhou.

Manter números inteiros ausentes

A coluna de quantidade dos pedidos contém números inteiros e um NaN, então é float64. O astype(int) comum falha porque NaN não tem representação inteira comum.

orders["quantity"] = orders["quantity"].astype("Int64")

O I maiúsculo importa: Int64, com suporte a valores ausentes, mantém a lacuna como <NA> enquanto armazena os valores conhecidos como números inteiros. Essa escolha é adequada para contagens com entradas ausentes. Ela não transforma uma quantidade realmente fracionária em uma contagem inteira válida.

Separadores de milhares em texto também precisam ser tratados. pd.Series(["1,200", "950"]).str.replace(",", "").astype(int) produz 1200 e 950. Quando o próprio arquivo usa essa convenção, thousands="," pode tratá-la durante a leitura.

Converter texto de datas

orders["date"] = pd.to_datetime(orders["date"])
orders["date"].dt.day_name()

A conversão permite usar .dt.year, .dt.month, .dt.day e .dt.day_name(). Para as seis datas dos pedidos, os nomes dos dias são Monday, Monday, Tuesday, Wednesday, Wednesday e Thursday. Executar pd.to_datetime(orders["date"]) sozinho produz uma Series convertida, mas deixa a coluna original como texto. É a atribuição que mantém o resultado.

Armazenar categorias repetidas

orders["category"].astype("category") armazena rótulos repetidos por meio de um conjunto de categorias permitidas. Em tabelas grandes, isso geralmente economiza memória. Atribua o resultado para mantê-lo, assim como em outras conversões.

O tipo categórico altera algumas operações. Suas categorias não são ordenadas por padrão, então min() e max() geram TypeError. O value_counts() de uma coluna categórica também lista categorias conhecidas ausentes de uma seleção filtrada com contagem zero. Escolher o tipo categórico é útil para rótulos repetidos, mas também altera o comportamento, além do armazenamento.

Os rótulos permitem solicitar uma linha ou coluna pelo seu significado. Com loc, um número de pedido identifica uma linha mesmo que a tabela tenha sido ordenada. A seleção tem uma parte para linhas seguida de uma parte para colunas: df.loc[rows, columns].

Começar com um índice significativo

O arquivo de pedidos tem seis linhas com identificadores de 1001 a 1006. Crie orders_by_id = orders.set_index("order_id"). Suas colunas, em ordem, são date, product, category, quantity e unit_price. Os rótulos das linhas são números de pedidos, não as posições de 0 a 5.

orders_by_id.loc[1003]
orders_by_id.loc[1004, "product"]

A primeira expressão retorna o pedido 1003 como uma Series: date "2026-03-03", product "Pen set", category "Stationery", quantity 2,0 e preço 4,75. A Series tem o nome 1003. A segunda retorna uma célula, "Mug".

Um rótulo ausente gera KeyError. orders_by_id.loc[0] falha: ter uma primeira linha na posição 0 não cria um rótulo 0.

Selecionar conjuntos de rótulos

orders_by_id.loc[[1001, 1005], ["product", "unit_price"]]

Listas selecionam rótulos na ordem solicitada. Isso produz duas linhas e duas colunas: Notebook a 2,5, depois Backpack a 35,0. Uma lista mantém um resultado em forma de tabela mesmo quando contém um único rótulo: .loc[[1003]] é um DataFrame de uma linha.

Dois-pontos isolados significam todos os rótulos ao longo desse eixo. Omitir o seletor de colunas também solicita todas as colunas.

Incluir os dois extremos de uma fatia por rótulos

orders_by_id.loc[1002:1004, "product":"quantity"]

Nesse índice ordenado, as linhas são 1002, 1003 e 1004. A fatia de colunas inclui product, category e quantity. Tanto o rótulo final das linhas quanto o das colunas são incluídos, então a forma é (3, 3). Aplicar aqui a regra usual do Python que exclui o extremo final omitiria uma linha e uma coluna desejadas.

Os rótulos permanecem após a ordenação

Um índice padrão pode ocultar a distinção entre rótulo e posição. Suponha que a ordenação de notas produza os rótulos de linha 3, 0, 2, 1, 4. .loc[0] continua selecionando o rótulo 0, agora na segunda linha exibida. .iloc[0] seleciona a primeira linha exibida, com rótulo 3. A ordenação move uma linha com seu rótulo; ela não renumera o índice silenciosamente.

Combinar uma condição com a seleção de colunas

O seletor de linhas pode ser uma Series booleana:

orders.loc[orders["unit_price"] > 5, ["product", "unit_price"]]

Isso mantém Desk lamp a 18,0, Mug a 6,0 e Backpack a 35,0, e retorna apenas as duas colunas solicitadas. A máscara decide quais linhas atendem à condição; a lista de colunas decide o que mostrar. A mesma forma com dois eixos pode selecionar células para atualização, colocando a seleção no lado esquerdo de uma atribuição.

Use iloc quando uma solicitação disser respeito à posição de uma linha ou coluna: as primeiras três linhas, a última coluna ou uma célula específica exibida. Seus seletores são posições inteiras, independentemente dos rótulos do índice.

Contar a partir de zero

orders.iloc[0] seleciona a primeira linha e orders.iloc[-1], a última. Uma posição negativa conta de trás para a frente. Duas posições selecionam uma célula: orders.iloc[2, 2] é "Pen set" na tabela original de pedidos, em que product está na posição de coluna 2.

A tabela indexada orders_by_id tem as colunas date, product, category, quantity e unit_price. Mover order_id para o índice alterou as posições das colunas, então product agora está na posição 1. O código baseado em posições depende dessa estrutura.

Parar antes do extremo final da fatia

orders_by_id.iloc[1:3, 0:2]

As posições de linha selecionadas são 1 e 2, que contêm os pedidos 1002 e 1003. As posições de coluna são 0 e 1, date e product. A posição 3 e a coluna 2 são excluídas, produzindo a forma (2, 2). Um início vazio significa o começo; um fim vazio significa o fim.

Listas solicitam posições específicas, incluindo uma mistura de posições positivas e negativas. orders.iloc[[0, -1], [2, 5]] seleciona product e unit_price para o primeiro e o último pedido. Ambos são Notebook a 2,5.

Prever a forma do resultado

Um escalar seleciona um item ao longo de um eixo e remove essa dimensão. Uma fatia ou lista mantém esse eixo, mesmo que selecione apenas um item. Isso importa quando a próxima operação espera uma tabela em vez de uma Series.

Tratar o fim de uma tabela

A tabela de pedidos de seis linhas tem posições de linha não negativas válidas de 0 a 5. orders.iloc[10] gera IndexError. Uma fatia pode ultrapassar a tabela: orders.iloc[4:100] simplesmente retorna as duas últimas linhas. Uma única posição inexistente é uma solicitação de item inválida, enquanto uma fatia descreve um intervalo limitado às linhas disponíveis.

Escolher rótulos ou posições de forma consciente

Para uma única célula, at usa rótulos e iat usa posições. orders.at[2, "product"] e orders.iat[2, 2] produzem "Pen set" antes de as linhas serem reordenadas.

Escolha loc quando souber um identificador ou o significado de uma coluna. Escolha iloc quando a própria localização importar. Para combinar as primeiras linhas com um nome de coluna, orders.columns.get_loc("quantity") retorna sua posição, 4, permitindo orders.iloc[0:3, 4].

Colchetes isolados podem mudar de função: orders["product"] seleciona uma coluna, mas orders[2:4] seleciona as posições de linha 2 e 3. Usar loc e iloc explicitamente torna essa escolha mais fácil de entender.

A filtragem seleciona observações que satisfazem uma pergunta, como quais pedidos pertencem a Home e custam mais de 10 por item. Primeiro, crie uma máscara booleana, uma Series com um True ou False por linha. Depois, use-a para selecionar as linhas correspondentes.

Construir e aplicar uma máscara

is_stationery = orders["category"] == "Stationery"
stationery = orders[is_stationery]

A máscara é True, False, True, False, False e True. A seleção mantém os rótulos 0, 2 e 5, correspondentes aos pedidos 1001, 1003 e 1006. A filtragem preserva esses rótulos; ela não os renumera. reset_index(drop=True) fornece rótulos consecutivos se necessário.

Os operadores de comparação incluem ==, !=, <, <=, > e >=. Comparações de texto exigem correspondência exata: "home" difere de "Home", e espaços também podem impedir uma correspondência.

Combinar condições linha por linha

is_home = orders["category"] == "Home"
is_expensive = orders["unit_price"] > 10
orders[is_home & is_expensive]

Apenas Desk lamp atende às condições: sua categoria é Home e seu preço é 18,0. Mug é da categoria Home, mas custa 6,0. Backpack custa 35,0, mas pertence a Bags.

Ao escrever comparações diretamente, coloque cada uma entre parênteses:

orders[(orders["category"] == "Home") &
       (orders["unit_price"] > 10)]

Use & para e, | para ou e ~ para não. Os parênteses mantêm cada comparação agrupada antes de o pandas combinar as máscaras. Sem eles, as regras de precedência do Python podem tentar combinar uma string e uma Series com & e gerar TypeError.

Os operadores and, or e not do Python esperam um único valor lógico, não uma coluna de valores lógicos. Usá-los em máscaras gera o ValueError de valor lógico ambíguo. Um simples if orders["quantity"] > 1: tem o mesmo problema. Use .any() para perguntar se alguma linha corresponde ou .all() para perguntar se todas correspondem.

Contar correspondências e proporções

is_stationery.sum() é 3 porque True conta como 1 e False como 0. is_stationery.mean() é 0,5, a fração dos seis pedidos que correspondem à condição. Multiplique por 100 para expressá-la como 50%.

Tratar valores ausentes explicitamente

Com a coluna original de quantidade float64, comparações que envolvem NaN produzem False, exceto !=, que produz True. quantity >= 1 mantém cinco linhas; quantity < 1 não mantém nenhuma. A quantidade em branco não está em nenhuma das seleções. Ainda assim, quantity != 3 inclui essa linha em branco, então ser diferente não significa ser conhecido e diferente.

Após a conversão para Int64 com suporte a valores ausentes, a comparação com <NA> produz <NA>, e a filtragem exclui essas linhas. Use isna() ou notna() quando a pergunta disser respeito a lacunas.

Para selecionar colunas além de linhas, use orders.loc[is_home, "product"]. Ele retorna Desk lamp e Mug. Uma máscara nomeada pode ser reutilizada para inspecionar, contar e atualizar o mesmo conjunto de linhas.

Alguns filtros têm formas conhecidas: pertencimento a uma lista, um intervalo numérico, um valor ausente ou um fragmento de texto. Métodos auxiliares expressam esses testes diretamente e ainda produzem máscaras que podem ser combinadas com outras condições.

Testar pertencimento e intervalos

orders[orders["category"].isin(["Home", "Bags"])]
orders[orders["unit_price"].between(4.75, 18)]

isin encontra correspondências com qualquer valor listado. A primeira seleção contém os pedidos 1002, 1004 e 1005. ~orders["category"].isin(["Home"]) inverte o teste de pertencimento e mantém as linhas de Stationery e Bags. Uma expressão in do Python não cria essa máscara de pertencimento linha por linha.

between inclui ambos os extremos por padrão. A segunda seleção inclui Desk lamp a 18,0, Pen set a 4,75 e Mug a 6,0. Use inclusive="neither" para excluir ambos os extremos, "left" para incluir apenas o extremo inferior ou "right" para incluir apenas o extremo superior. Escolha a regra dos extremos de acordo com a pergunta feita.

Encontrar entradas ausentes e presentes

orders[orders["quantity"].isna()] mantém o pedido 1006. notna() faz o contrário, mantendo as quantidades registradas. Não teste igualdade com np.nan: NaN é diferente até de si mesmo, então quantity == np.nan não encontra a linha ausente.

Procurar dentro do texto

orders[orders["product"].str.contains("note", case=False, na=False)]

str.contains testa se cada valor de texto contém uma correspondência. Ignorar maiúsculas e minúsculas encontra ambas as linhas com Notebook. na=False faz com que texto ausente conte como sem correspondência. Por padrão, a busca trata seu padrão como uma expressão regular; para um fragmento de texto literal com pontuação, regex=False evita interpretar essa pontuação como um padrão. str.startswith e str.endswith testam o início e o fim.

Escrever um filtro como consulta

orders.query("quantity >= 2 and unit_price < 5")

Isso mantém os pedidos 1001 e 1003. Dentro de uma string de query, nomes de colunas representam colunas e and, or e not são permitidos. A string é uma expressão de consulta do pandas; sua sintaxe difere daquela usada para combinar Series diretamente no Python comum.

Uma variável Python precisa de @:

limit = 5
orders.query("unit_price > @limit")

O resultado contém Desk lamp, Mug e Backpack. Um nome de coluna que contém espaço precisa ficar entre crases dentro da consulta, como em orders.query("`unit price` > 5").

A mesma pergunta pode ser escrita como uma máscara, uma chamada de método auxiliar ou uma consulta. Prefira a forma que exponha a regra com clareza. Para um intervalo, between reúne os limites e a regra de inclusão. Para um conjunto de rótulos permitidos, isin evita repetir testes de igualdade. Quando um filtro se comportar de modo inesperado, inspecione a máscara e os valores exatos da coluna antes de alterar a condição.

Uma atualização precisa ter como alvo a tabela que você pretende alterar. No pandas 3, uma seleção se comporta como um objeto separado sob a cópia na escrita, então alterar um objeto selecionado não altera sua tabela de origem.

Colocar todo o alvo em uma atribuição com loc

sale = orders.copy()
is_home = sale["category"] == "Home"
sale.loc[is_home, "unit_price"] *= 0.9

A máscara seleciona duas linhas de Home. O seletor de coluna direciona a operação aos seus preços. A multiplicação por 0,9 mantém 90% de cada preço, reduzindo 18,00 para 16,20 e 6,00 para 5,40. As outras linhas não são alteradas. A forma expandida lê a mesma seleção no lado direito e atribui seus valores multiplicados no lado esquerdo.

Aqui, sale é uma tabela separada usada para uma alteração de preços, deixando orders disponível para comparação. Para atualizar a tabela original, coloque o próprio orders.loc[...] no lado esquerdo da atribuição.

Evitar atribuição encadeada

orders[orders["category"] == "Home"]["unit_price"] = 0

Isso usa duas etapas de indexação. A primeira produz um objeto selecionado; a segunda atribui valores a esse objeto. No pandas 3, isso nunca atualiza orders, e um aviso ChainedAssignmentError aponta o problema. A mesma questão afeta orders["unit_price"][1] = 0.

Use orders.loc[orders["category"] == "Home", "unit_price"] = 0 quando a alteração desejada for na tabela original. A tabela, as linhas correspondentes e a coluna são especificadas em uma única atribuição.

Entender tabelas selecionadas

Após home = orders[orders["category"] == "Home"], alterar home["unit_price"] altera apenas home. Alterações posteriores em orders também não alteram home. Os objetos podem compartilhar armazenamento internamente até que uma gravação seja necessária, mas seus valores visíveis se comportam de forma independente.

Exemplos mais antigos de pandas podem mostrar SettingWithCopyWarning e usar .copy() após a seleção para evitar atualizações incertas. O pandas 3 removeu esse aviso e tornou consistente a independência das seleções. Um .copy() explícito ainda é útil para declarar a intenção, mas uma seleção já se comporta de forma independente nas atualizações.

Associar os valores do lado direito ao alvo

Um escalar preenche todas as células selecionadas. Uma lista precisa de exatamente um valor por linha selecionada e as preenche na ordem da seleção. Uma Series se alinha pelo rótulo do índice:

new_prices = pd.Series([16.2, 5.4], index=[1, 3])
sale.loc[is_home, "unit_price"] = new_prices

As linhas de Home têm os rótulos 1 e 3, então recebem 16,2 e 5,4. Se um rótulo selecionado estivesse ausente da Series, seu valor atribuído seria NaN; linhas fora da seleção permaneceriam inalteradas. Comprimentos iguais, por si só, não estabelecem uma correspondência entre a Series e as linhas.

Inspecione sale.loc[is_home, "unit_price"] após a alteração e compare-o com orders.loc[is_home, "unit_price"]. O .sum() da máscara é 2, o que fornece o número esperado de linhas selecionadas para esse desconto.

Novas colunas transformam dados registrados em quantidades que você pode analisar. Um cálculo entre colunas funciona linha por linha, enquanto o índice mantém cada resultado ligado à sua observação.

Calcular receita

orders["revenue"] = orders["quantity"] * orders["unit_price"]

As seis receitas são 7,5; 18,0; 9,5; 24,0; 35,0 e NaN. Para a primeira linha, três itens a 2,50 cada produzem 7,50. A última linha tem uma quantidade desconhecida, então sua receita também é desconhecida. Atribuir a um novo nome adiciona uma coluna à direita; atribuir a um nome existente sobrescreve essa coluna.

A aritmética entre colunas é vetorizada. Ela expressa uma regra para a coluna inteira e evita um laço Python sobre as linhas. Em tabelas grandes, isso é muito mais rápido que for ou iterrows, e a expressão torna clara a relação entre as entradas.

Usar os valores registrados em um total

orders["revenue"].sum() ignora NaN e produz 94,0, o total das cinco receitas conhecidas. .mean() produz 18,8 porque o denominador é de cinco receitas registradas. Dividir 94,0 pelas seis linhas trataria silenciosamente a receita ausente como se ela contribuísse com um zero conhecido.

Para calcular as participações percentuais:

orders["share_pct"] = (
    orders["revenue"] / orders["revenue"].sum() * 100
).round(1)

As participações são 8,0; 19,1; 10,1; 25,5; 37,2 e NaN. Essas são participações no total conhecido. A entrada ausente permanece ausente ao longo da aritmética.

Retornar uma tabela com assign

assign retorna um novo DataFrame com colunas adicionadas ou substituídas, deixando sua entrada inalterada. Ele funciona naturalmente em uma sequência de métodos:

with_tax = orders.assign(
    tax=lambda d: (d["revenue"] * 0.2).round(2)
)

A lambda lê a tabela naquele ponto da sequência. Ela produz valores de imposto de 1,5; 3,6; 1,9; 4,8; 7,0 e NaN. No pandas 3, pd.col("revenue") * 0.2 é outra maneira de se referir a uma coluna em assign.

Cálculos decimais podem revelar pequenos erros de representação binária de ponto flutuante: 9,5 vezes 0,2 pode ser armazenado como 1.9000000000000001. .round(2) fornece um valor útil para apresentação. Evite testes de igualdade exata em decimais calculados quando pequenos erros de representação forem possíveis.

Saber como a atribuição associa linhas

orders["home_price"] = orders.loc[
    orders["category"] == "Home", "unit_price"
]

A Series atribuída tem os rótulos 1 e 3. Essas linhas recebem 18,0 e 6,0; todas as outras recebem NaN. A atribuição de uma Series associa rótulos, mesmo quando seu comprimento difere do da tabela. Uma lista comum não tem rótulos e deve conter exatamente um valor por linha. Um escalar, como orders["currency"] = "EUR", preenche todas as linhas.

Derivar valores de texto ou datas

Os acessores .str e .dt também fornecem operações vetorizadas em colunas. orders["product"].str.upper() produz nomes em maiúsculas, e .str.len() fornece comprimentos 8, 9, 7, 3, 8 e 8. Atribua esses resultados a uma nova coluna quando tanto os valores originais quanto os derivados forem úteis.

Transformar uma coluna pode significar aplicar uma regra numérica, atribuir um rótulo ou traduzir rótulos existentes. Escolha um método cujo comportamento corresponda à regra, especialmente para valores que ela não menciona.

Transformar uma condição em rótulos

orders["price_band"] = np.where(
    orders["unit_price"] >= 5, "high", "low"
)

np.where escolhe seu segundo argumento quando a condição é True e seu terceiro quando ela é False. Para os preços 2,50; 18,00; 4,75; 6,00; 35,00 e 2,50, os rótulos são low, high, low, high, high e low. O >= inclui um preço exatamente igual a 5.

Traduzir todos os valores ou alterar alguns

codes = {"Stationery": "ST", "Home": "HM", "Bags": "BG"}
orders["category_code"] = orders["category"].map(codes)

map com dicionário produz ST, HM, ST, HM, BG e ST. Um valor ausente do dicionário se torna NaN. Com apenas {"Stationery": "ST"}, tanto Home quanto Bags se tornam ausentes. Use um mapeamento completo quando cada categoria precisar de um código traduzido.

replace altera valores listados e deixa os não listados inalterados. orders["category"].replace({"Bags": "Luggage"}) mantém Stationery e Home enquanto renomeia Bags.

Aplicar uma função personalizada

Uma Series pode passar cada valor a uma função por meio de map ou apply. orders["product"].apply(len) retorna o comprimento do nome de cada produto. Passe o próprio len; len() o chamaria imediatamente sem um valor.

Uma lambda pode expressar uma pequena regra para valores: orders["unit_price"].apply(lambda p: "budget" if p < 5 else "standard"). Isso retorna budget, standard, budget, standard, standard e budget.

Para uma lógica que exige várias células em uma linha, o apply de DataFrame aceita axis=1:

orders.apply(
    lambda r: r["quantity"] * r["unit_price"], axis=1
)

A função lê a quantidade e o preço de cada linha. Para essa operação, a multiplicação direta de colunas é mais clara e muito mais rápida em uma tabela grande. Use expressões vetorizadas ou np.where quando puderem expressar o cálculo; reserve funções por linha para lógicas que precisem delas.

Usar transformações numéricas disponíveis

round(n) arredonda para n casas decimais, abs() fornece valores absolutos e clip(lower=..., upper=...) limita valores aos limites informados. orders["unit_price"].clip(upper=20) altera 35,0 para 20,0 e deixa os outros cinco preços inalterados. Ele não remove a linha de preço alto.

Essas transformações retornam novos valores. Atribua-os a uma nova coluna para preservar a entrada para verificação ou sobrescreva a original quando essa for a intenção. Inspecione algumas linhas transformadas ou execute value_counts() para verificar se os novos rótulos e suas contagens correspondem à regra.

Ordenar altera a ordem em que as observações aparecem. A operação mantém juntos os valores de cada linha e leva consigo o rótulo da linha. Decida o que tem prioridade e como valores empatados devem ser ordenados antes de selecionar os maiores ou menores.

Ordenar uma coluna

scores = pd.DataFrame({
    "name": ["Ana", "Ben", "Chen", "Dara", "Eli"],
    "points": [88, 92, 88, 75, 92]
})
ordered = scores.sort_values("points")

Por padrão, o menor vem primeiro. Os 75 de Dara vêm primeiro, seguidos dos dois valores 88 e depois dos dois valores 92. Os rótulos das linhas se movem com os registros. Entre empates, o algoritmo de ordenação padrão não garante a ordem original; os rótulos exibidos podem ser 3, 0, 2, 1, 4, mas não se deve presumir que linhas empatadas mantenham essa ordem.

Use ascending=False para colocar o maior primeiro. sort_values retorna uma tabela, deixando scores inalterado, a menos que seu resultado seja atribuído.

Escolher como resolver empates

scores.sort_values(
    ["points", "name"], ascending=[False, True]
)

A primeira chave tem prioridade. Os pontos diminuem; os nomes aumentam dentro de pontuações iguais. A ordem é Ben, Eli, Ana, Chen e Dara. Ordenar nomes primeiro responderia a uma pergunta diferente porque tornaria os nomes a chave principal.

Quando empates em uma coluna devem preservar a ordem de entrada, use scores.sort_values("points", kind="stable"). A estabilidade mantém as linhas empatadas em sua sequência atual. Uma chave secundária, por sua vez, dá aos empates uma regra explícita de ordenação.

Posicionar valores ausentes e texto

Valores ausentes vão para o fim por padrão, tanto na ordenação crescente quanto na decrescente. pd.Series([3.0, np.nan, 1.0]).sort_values() produz 1,0; 3,0 e depois NaN. na_position="first" move a entrada ausente para o início; inverter apenas a direção da ordenação não faz isso.

A ordenação de texto segue os códigos dos caracteres. "Zebra" vem antes de "apple" porque letras maiúsculas e minúsculas ocupam intervalos diferentes. Nomes escritos de forma consistente, como Bags, Home e Stationery, são ordenados na ordem alfabética esperada.

Ordenar rótulos ou renumerá-los

sort_index() ordena os rótulos das linhas, não os valores dos dados. Após ordenar por pontos, ele pode restaurar a ordem original dos rótulos padrão. sort_index(ascending=False) inverte a ordem dos rótulos. Já reset_index(drop=True) mantém a ordem atual das linhas e substitui seus rótulos por 0, 1, 2 e assim por diante.

Selecionar as linhas com maiores ou menores valores

scores.nlargest(2, "points") retorna Ben e Eli, ambos com 92. nsmallest seleciona valores baixos. Se o corte ocorrer em um empate, decida se deseja manter todas as linhas empatadas. scores.nlargest(1, "points", keep="all") retorna os dois valores 92, embora n seja 1. O número solicitado é então um ponto de corte, não uma garantia sobre a contagem final de linhas.

Um posto registra a posição de um valor na ordem classificada sem mover sua linha. Isso é útil quando cada observação precisa de um número de posição junto aos dados originais. Empates precisam de uma regra porque vários valores podem ocupar a mesma parte dessa ordem.

Escolher a direção

scores["points"].rank() atribui postos do menor para o maior. Use ascending=False para uma tabela de resultados em que pontuações altas devem receber os melhores postos. O método para empates decide então qual número de posição cada grupo empatado recebe.

As pontuações do exemplo na ordem das linhas são Ana 88, Ben 92, Chen 88, Dara 75 e Eli 92. Em ordem decrescente, os valores 92 ocupam as posições 1 e 2, os valores 88 ocupam as posições 3 e 4, e 75 ocupa a posição 5. O padrão method="average" atribui a cada valor empatado a média das posições que ele ocupa. Os valores retornados, na ordem original das linhas, são 3,5; 1,5; 3,5; 5,0 e 1,5.

Escolher um método para empates

Com min, dois vencedores no posto 1 significam que a próxima pontuação começa no posto 3. Com dense, a próxima pontuação distinta começa no posto 2. first desempata mesmo quando as próprias pontuações não fornecem motivo para preferir uma pessoa; ele segue a ordem de entrada.

Os resultados dos postos são números de ponto flutuante, permitindo valores como 1,5. Quando o método escolhido para empates fornece postos inteiros e nenhum está ausente, .astype(int) os converte para exibição. Um tipo inteiro comum não pode armazenar um posto ausente.

Expressar postos como frações

Para o método padrão da média e valores não ausentes, rank(pct=True) divide cada posto pelo número de valores classificados. Classificar as cinco pontuações do exemplo em ordem crescente produz 2,5; 4,5; 2,5; 1,0 e 4,5. Dividir por cinco produz 0,5; 0,9; 0,5; 0,2 e 0,9.

Os maiores valores empatados recebem 0,9, não 1, porque seu posto médio é 4,5. Um posto percentílico descreve a posição relativa aos valores classificados; ele não é uma porcentagem da própria pontuação.

Tratar postos ausentes e armazenar resultados

Valores ausentes mantêm postos NaN por padrão. Com as receitas 7,5; 18,0; 9,5; 24,0; 35,0 e NaN, os postos decrescentes são 5, 3, 4, 2, 1 e NaN. na_option="bottom" coloca a entrada ausente após os valores registrados, atribuindo-lhe o posto 6.

scores["place"] = scores["points"].rank(
    method="min", ascending=False
)

As linhas permanecem Ana, Ben, Chen, Dara e Eli. A nova coluna de posição registra 3, 1, 3, 5 e 1. Ordene separadamente se a exibição deve mostrar os vencedores primeiro.

Uma estatística descritiva resume muitas observações em uma quantidade útil. Escolha uma estatística adequada à pergunta e leia sua contagem de valores não ausentes para saber quantos dados a sustentam.

Calcular medidas de tendência central e dispersão

weather = pd.DataFrame({
    "temp_c": [14.0, 17.5, 16.0, 21.0, 19.5, 12.5, 15.0],
    "rain_mm": [0.0, 2.4, 0.0, 0.0, 5.1, 12.3, 0.8]
}, index=["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"])

Para weather["temp_c"], sum() é 115,5, mean() é 16,5 e median() é 16,0. O mínimo é 12,5 e o máximo é 21,0, produzindo uma amplitude de 8,5 °C. idxmax() retorna o rótulo "Thu", enquanto idxmin() retorna "Sat": eles identificam observações em vez de retornar os próprios valores extremos.

std() e var() medem a dispersão. O pandas usa o denominador amostral por padrão, ddof=1, dividindo os desvios quadráticos por um a menos que a contagem. Aqui o desvio padrão é aproximadamente 3,028 °C e a variância é aproximadamente 9,167 graus Celsius quadrados. std(ddof=0) usa a própria contagem e produz aproximadamente 2,803 °C. A função np.std do NumPy usa ddof=0 por padrão, então iguale a configuração antes de comparar resultados.

Ler quartis e describe

quantile(0.25) fornece o quartil inferior, 14,5; quantile(0.5) fornece a mediana, 16,0; quantile(0.75) fornece o quartil superior, 18,5. A interpolação padrão pode retornar um valor entre medições registradas.

weather.describe() combina contagem, média, desvio padrão, mínimo, os três quartis e máximo para colunas numéricas. A chuva tem média de aproximadamente 2,94 mm e mediana de 0,8 mm. A medição de 12,3 mm eleva a média; a mediana descreve melhor um dia típico nessa semana com assimetria à direita.

Considerar valores ausentes e tipos

Para pd.Series([1, np.nan, 3]), .mean() é 2,0 porque valores ausentes são ignorados por padrão. .count() é 2, enquanto .size é 3. Com skipna=False, a média é NaN. Não use a contagem total de linhas como denominador para a média padrão quando algumas entradas estiverem ausentes.

Resumos de texto são diferentes. orders["category"].describe() produz count 6, unique 3, top Stationery e freq 3. Calcular a média da tabela de pedidos com texto misturado gera TypeError; use orders.mean(numeric_only=True) ou selecione colunas numéricas com select_dtypes("number").

Resumir ao longo de um eixo

Por padrão, estatísticas de DataFrame reduzem ao longo das linhas para um resultado por coluna. axis=1 fornece um resultado por linha; selecione quantidades cujas unidades possam ser combinadas de modo sensato.

orders[["quantity", "unit_price"]].agg(["mean", "max"])

agg calcula várias estatísticas nomeadas em conjunto. Quantity tem média 2,2 e máximo 4,0; unit_price tem média de aproximadamente 11,46 e máximo 35,0. weather["rain_mm"].cumsum() fornece os totais acumulados 0,0; 2,4; 2,4; 2,4; 7,5; 19,8 e 20,6 mm, preservando um resultado por dia.

Contagens descrevem quantas vezes valores ocorrem; correlações descrevem como duas variáveis numéricas variam em conjunto. Ambos os resumos precisam de interpretação: o que está sendo contado, o que está ausente e qual relação a estatística mede.

Contar categorias ou listar valores distintos

orders["category"].value_counts() produz Stationery 3, Home 2 e Bags 1, ordenados por frequência. A Series retornada se chama count. Entradas ausentes são excluídas por padrão; dropna=False as inclui como uma contagem separada.

orders["category"].value_counts(normalize=True)

A Series normalizada se chama proportion: Stationery é 0,5, Home é aproximadamente 0,333 e Bags é aproximadamente 0,167. Multiplicar por 100 expressa porcentagens. Com a regra padrão para valores ausentes, essas proporções descrevem os valores presentes.

unique() mantém a ordem da primeira ocorrência: Stationery, Home, Bags. mode() retorna uma Series porque vários valores podem empatar pela maior frequência. Ele não solicita um único vencedor escolhido arbitrariamente.

Condições podem ser contadas diretamente. (weather["rain_mm"] > 0).sum() conta quatro dias chuvosos. Seu .mean() é aproximadamente 0,571, então cerca de 57% dos sete dias tiveram chuva.

Medir uma relação linear

weather["temp_c"].corr(weather["rain_mm"]) fornece uma correlação de Pearson de aproximadamente −0,397. Seu sinal negativo indica que dias mais quentes tenderam a ter menos chuva nessas observações. Sua magnitude descreve quão bem um padrão linear se ajusta aos dados, em uma escala de −1, passando por 0, até 1.

Um valor de 1 significa uma relação linear crescente perfeita; −1 significa uma relação decrescente perfeita. Um valor próximo de zero significa pouca associação linear. Uma relação curva ainda pode ser forte mesmo quando a correlação de Pearson está próxima de zero. Correlação também diz respeito à associação, não é evidência de que alterar uma variável cause a alteração da outra.

Ler uma matriz de correlação

weather.corr() fornece todos os pares numéricos em conjunto. A matriz é simétrica: temperatura com chuva tem a mesma correlação que chuva com temperatura. Uma coluna numérica que varia tem correlação 1 consigo mesma; uma coluna constante não tem correlação definida e produz NaN.

Para relações que aumentam ou diminuem consistentemente sem seguir uma linha reta, method="spearman" calcula a correlação a partir dos postos. O método altera o tipo de padrão resumido, então informe-o ao relatar um resultado.

O cálculo meteorológico usa apenas sete medições. Ele descreve essa pequena semana observada; afirmações fortes sobre um padrão climático mais amplo precisam de mais evidências. Um relatório útil inclui as variáveis, o sinal e o tamanho do coeficiente, o método e o número de observações.