Estatística

Somatório: o que é e como calcular

Capa do artigo Somatório: o que é e como calcular
Leitura com foco

Entenda o contexto.
Leve para a prática.

Neste artigo
  1. O que é um somatório?
  2. Como escrever a média com somatório?
  3. Como calcular um somatório em Python, PHP e C?
  4. Quais são as propriedades do somatório?
  5. Por que a soma dos desvios em relação à média dá zero?
  6. Existe atalho para somar de 1 até n?
  7. O que é um somatório duplo?
  8. Aí você pergunta: e se a lista estiver vazia?
  9. Quais são os erros mais comuns com somatório?
  10. Agora é com você!

Somatório é a soma de uma sequência de valores, escrita de forma abreviada com a letra grega sigma maiúscula (Σ). Também é chamado de notação sigma. Em vez de escrever x1 + x2 + x3 + … + xn, você escreve um símbolo só, com três informações: o que somar, onde começar e onde parar.

Se você já calculou uma média, já fez um somatório: somou todos os valores antes de dividir. E, se já escreveu um laço de repetição com uma variável que vai acumulando um total, já programou um. Este artigo junta as duas coisas.

Pense na conta do mercado. O caixa passa item por item, e o visor mostra o total subindo. No fim, o valor a pagar é a soma de todos os preços. O somatório é o jeito de escrever “some todos os preços, do primeiro ao último” sem listar um por um.

O que é um somatório?

É uma soma escrita com quatro partes:

  • O sigma (Σ): a ordem de somar.
  • O índice: a letra que conta as parcelas. Aqui, i.
  • Os limites: embaixo do sigma, o valor em que o índice começa (limite inferior). Em cima, o valor em que ele termina (limite superior).
  • O termo geral: à direita do sigma, o que entra na soma para cada valor do índice.
Diagrama das partes de um somatório: o sigma, o limite superior n, o termo geral x índice i e o índice i começando em 1
O índice assume cada valor inteiro entre os dois limites, incluindo os dois. Cada valor gera uma parcela.

Tome as notas 7, 5, 8, 6 e 9. Chamando a primeira de x1, a segunda de x2 e assim por diante, o somatório das cinco notas fica assim:

 5
 Σ  x_i  =  x_1 + x_2 + x_3 + x_4 + x_5  =  7 + 5 + 8 + 6 + 9  =  35
i=1

A letra do índice não muda nada. Trocar i por k ou por j dá a mesma soma.

Como escrever a média com somatório?

A média aritmética é a soma de todos os valores dividida pela quantidade deles. Com o somatório, a frase inteira cabe em uma linha:

           n
média  =  ( Σ  x_i )  ÷  n
          i=1

Para as cinco notas: 35 ÷ 5 = 7.

Como calcular um somatório em Python, PHP e C?

O somatório vira um laço com um acumulador: uma variável que começa em zero e recebe uma parcela a cada volta. O programa abaixo faz isso e depois testa, com números, cada propriedade que vem a seguir.

Python:

# Somatório: a soma de uma lista de valores, escrita com a letra sigma

notas = [7, 5, 8, 6, 9]
n = len(notas)

# o somatório é um laço com um acumulador
soma = 0
for i in range(n):
    soma = soma + notas[i]
    print("i = %d   x = %d   soma parcial = %d" % (i + 1, notas[i], soma))

print()
print("soma dos valores:", soma)
print("com uma função:", sum(notas))

media = soma // n
print("média:", media)

# constante multiplicando: pode sair do somatório
soma_dobro = 0
for x in notas:
    soma_dobro = soma_dobro + 2 * x
print()
print("soma de 2x: %d   2 vezes a soma: %d" % (soma_dobro, 2 * soma))

# somatório de uma constante: n vezes a constante
soma_const = 0
for i in range(n):
    soma_const = soma_const + 3
print("soma de 3, cinco vezes: %d   5 vezes 3: %d" % (soma_const, n * 3))

# soma de duas listas: pode separar em dois somatórios
pesos = [1, 2, 2, 1, 4]
soma_juntos = 0
soma_pesos = 0
for i in range(n):
    soma_juntos = soma_juntos + (notas[i] + pesos[i])
    soma_pesos = soma_pesos + pesos[i]
print("soma de (x + y): %d   soma de x mais soma de y: %d" % (soma_juntos, soma + soma_pesos))

# soma dos quadrados não é o quadrado da soma
soma_quadrados = 0
for x in notas:
    soma_quadrados = soma_quadrados + x * x
print()
print("soma dos quadrados: %d   quadrado da soma: %d" % (soma_quadrados, soma * soma))

# soma dos produtos não é o produto das somas
soma_produtos = 0
for i in range(n):
    soma_produtos = soma_produtos + notas[i] * pesos[i]
print("soma dos produtos: %d   produto das somas: %d" % (soma_produtos, soma * soma_pesos))

# soma dos desvios em relação à média
soma_desvios = 0
for x in notas:
    soma_desvios = soma_desvios + (x - media)
print("soma dos desvios em relação à média:", soma_desvios)

# soma de 1 até n e a fórmula fechada
print()
for limite in [10, 100, 1000]:
    total = 0
    for i in range(1, limite + 1):
        total = total + i
    print("soma de 1 até %d: %d   fórmula n(n+1)/2: %d" % (limite, total, limite * (limite + 1) // 2))

# somatório duplo: soma de todos os elementos de uma tabela
vendas = [[4, 2, 6],
          [1, 5, 3]]
total_geral = 0
print()
for i in range(2):
    total_linha = 0
    for j in range(3):
        total_linha = total_linha + vendas[i][j]
    print("linha %d: %d" % (i + 1, total_linha))
    total_geral = total_geral + total_linha
print("total geral:", total_geral)

PHP:

<?php
// Somatório: a soma de uma lista de valores, escrita com a letra sigma

$notas = [7, 5, 8, 6, 9];
$n = count($notas);

// o somatório é um laço com um acumulador
$soma = 0;
for ($i = 0; $i < $n; $i++) {
    $soma = $soma + $notas[$i];
    printf("i = %d   x = %d   soma parcial = %d\n", $i + 1, $notas[$i], $soma);
}

echo "\nsoma dos valores: $soma\n";
echo "com uma função: " . array_sum($notas) . "\n";

$media = intdiv($soma, $n);
echo "média: $media\n";

// constante multiplicando: pode sair do somatório
$soma_dobro = 0;
foreach ($notas as $x) {
    $soma_dobro = $soma_dobro + 2 * $x;
}
printf("\nsoma de 2x: %d   2 vezes a soma: %d\n", $soma_dobro, 2 * $soma);

// somatório de uma constante: n vezes a constante
$soma_const = 0;
for ($i = 0; $i < $n; $i++) {
    $soma_const = $soma_const + 3;
}
printf("soma de 3, cinco vezes: %d   5 vezes 3: %d\n", $soma_const, $n * 3);

// soma de duas listas: pode separar em dois somatórios
$pesos = [1, 2, 2, 1, 4];
$soma_juntos = 0;
$soma_pesos = 0;
for ($i = 0; $i < $n; $i++) {
    $soma_juntos = $soma_juntos + ($notas[$i] + $pesos[$i]);
    $soma_pesos = $soma_pesos + $pesos[$i];
}
printf("soma de (x + y): %d   soma de x mais soma de y: %d\n", $soma_juntos, $soma + $soma_pesos);

// soma dos quadrados não é o quadrado da soma
$soma_quadrados = 0;
foreach ($notas as $x) {
    $soma_quadrados = $soma_quadrados + $x * $x;
}
printf("\nsoma dos quadrados: %d   quadrado da soma: %d\n", $soma_quadrados, $soma * $soma);

// soma dos produtos não é o produto das somas
$soma_produtos = 0;
for ($i = 0; $i < $n; $i++) {
    $soma_produtos = $soma_produtos + $notas[$i] * $pesos[$i];
}
printf("soma dos produtos: %d   produto das somas: %d\n", $soma_produtos, $soma * $soma_pesos);

// soma dos desvios em relação à média
$soma_desvios = 0;
foreach ($notas as $x) {
    $soma_desvios = $soma_desvios + ($x - $media);
}
echo "soma dos desvios em relação à média: $soma_desvios\n";

// soma de 1 até n e a fórmula fechada
echo "\n";
foreach ([10, 100, 1000] as $limite) {
    $total = 0;
    for ($i = 1; $i <= $limite; $i++) {
        $total = $total + $i;
    }
    printf("soma de 1 até %d: %d   fórmula n(n+1)/2: %d\n", $limite, $total, intdiv($limite * ($limite + 1), 2));
}

// somatório duplo: soma de todos os elementos de uma tabela
$vendas = [[4, 2, 6],
           [1, 5, 3]];
$total_geral = 0;
echo "\n";
for ($i = 0; $i < 2; $i++) {
    $total_linha = 0;
    for ($j = 0; $j < 3; $j++) {
        $total_linha = $total_linha + $vendas[$i][$j];
    }
    printf("linha %d: %d\n", $i + 1, $total_linha);
    $total_geral = $total_geral + $total_linha;
}
echo "total geral: $total_geral\n";

C:

/* Somatório: a soma de uma lista de valores, escrita com a letra sigma */
#include <stdio.h>

/* função que soma os n primeiros elementos de um vetor */
int somar(const int v[], int n) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        total = total + v[i];
    }
    return total;
}

int main(void) {
    int notas[] = {7, 5, 8, 6, 9};
    int n = 5;

    /* o somatório é um laço com um acumulador */
    int soma = 0;
    for (int i = 0; i < n; i++) {
        soma = soma + notas[i];
        printf("i = %d   x = %d   soma parcial = %d\n", i + 1, notas[i], soma);
    }

    printf("\nsoma dos valores: %d\n", soma);
    printf("com uma função: %d\n", somar(notas, n));

    int media = soma / n;
    printf("média: %d\n", media);

    /* constante multiplicando: pode sair do somatório */
    int soma_dobro = 0;
    for (int i = 0; i < n; i++) {
        soma_dobro = soma_dobro + 2 * notas[i];
    }
    printf("\nsoma de 2x: %d   2 vezes a soma: %d\n", soma_dobro, 2 * soma);

    /* somatório de uma constante: n vezes a constante */
    int soma_const = 0;
    for (int i = 0; i < n; i++) {
        soma_const = soma_const + 3;
    }
    printf("soma de 3, cinco vezes: %d   5 vezes 3: %d\n", soma_const, n * 3);

    /* soma de duas listas: pode separar em dois somatórios */
    int pesos[] = {1, 2, 2, 1, 4};
    int soma_juntos = 0, soma_pesos = 0;
    for (int i = 0; i < n; i++) {
        soma_juntos = soma_juntos + (notas[i] + pesos[i]);
        soma_pesos = soma_pesos + pesos[i];
    }
    printf("soma de (x + y): %d   soma de x mais soma de y: %d\n", soma_juntos, soma + soma_pesos);

    /* soma dos quadrados não é o quadrado da soma */
    int soma_quadrados = 0;
    for (int i = 0; i < n; i++) {
        soma_quadrados = soma_quadrados + notas[i] * notas[i];
    }
    printf("\nsoma dos quadrados: %d   quadrado da soma: %d\n", soma_quadrados, soma * soma);

    /* soma dos produtos não é o produto das somas */
    int soma_produtos = 0;
    for (int i = 0; i < n; i++) {
        soma_produtos = soma_produtos + notas[i] * pesos[i];
    }
    printf("soma dos produtos: %d   produto das somas: %d\n", soma_produtos, soma * soma_pesos);

    /* soma dos desvios em relação à média */
    int soma_desvios = 0;
    for (int i = 0; i < n; i++) {
        soma_desvios = soma_desvios + (notas[i] - media);
    }
    printf("soma dos desvios em relação à média: %d\n", soma_desvios);

    /* soma de 1 até n e a fórmula fechada */
    int limites[] = {10, 100, 1000};
    printf("\n");
    for (int t = 0; t < 3; t++) {
        int limite = limites[t];
        int total = 0;
        for (int i = 1; i <= limite; i++) {
            total = total + i;
        }
        printf("soma de 1 até %d: %d   fórmula n(n+1)/2: %d\n", limite, total, limite * (limite + 1) / 2);
    }

    /* somatório duplo: soma de todos os elementos de uma tabela */
    int vendas[2][3] = {{4, 2, 6},
                        {1, 5, 3}};
    int total_geral = 0;
    printf("\n");
    for (int i = 0; i < 2; i++) {
        int total_linha = 0;
        for (int j = 0; j < 3; j++) {
            total_linha = total_linha + vendas[i][j];
        }
        printf("linha %d: %d\n", i + 1, total_linha);
        total_geral = total_geral + total_linha;
    }
    printf("total geral: %d\n", total_geral);
    return 0;
}

Saída:

i = 1   x = 7   soma parcial = 7
i = 2   x = 5   soma parcial = 12
i = 3   x = 8   soma parcial = 20
i = 4   x = 6   soma parcial = 26
i = 5   x = 9   soma parcial = 35

soma dos valores: 35
com uma função: 35
média: 7

soma de 2x: 70   2 vezes a soma: 70
soma de 3, cinco vezes: 15   5 vezes 3: 15
soma de (x + y): 45   soma de x mais soma de y: 45

soma dos quadrados: 255   quadrado da soma: 1225
soma dos produtos: 75   produto das somas: 350
soma dos desvios em relação à média: 0

soma de 1 até 10: 55   fórmula n(n+1)/2: 55
soma de 1 até 100: 5050   fórmula n(n+1)/2: 5050
soma de 1 até 1000: 500500   fórmula n(n+1)/2: 500500

linha 1: 12
linha 2: 9
total geral: 21

O Python tem a função sum, e o PHP tem a array_sum, que fazem o laço por você. No programa em C, a função somar foi escrita à mão. Foque no conceito, e não na linguagem! Nos três casos, o que acontece por baixo é o mesmo acumulador.

ATENÇÃO: no somatório deste artigo o índice começa em 1. Nos três programas, a primeira posição do vetor é a 0. Por isso o laço vai de 0 até n − 1, e a saída mostra i + 1.

Ver a animação do acumulador somando as cinco notas
Animação do acumulador somando 7, 5, 8, 6 e 9 até chegar a 35
A cada volta, o acumulador recebe uma parcela. Depois de cinco voltas, ele guarda o somatório.

Quais são as propriedades do somatório?

São três regras que permitem mexer na conta sem mudar o resultado. Ao lado de cada uma está o que o programa mediu.

  • Constante multiplicando sai do somatório. Somar o dobro de cada nota é o mesmo que dobrar a soma: 70 e 70.
  • Soma de duas listas separa em dois somatórios. Somar nota + peso, par a par, é o mesmo que somar as notas, somar os pesos e juntar: 45 e 45.
  • Somatório de uma constante é n vezes a constante. Somar o número 3 cinco vezes dá 5 × 3: 15 e 15.

E duas coisas que não valem:

  • A soma dos quadrados não é o quadrado da soma. Elevar cada nota ao quadrado e somar dá 255. Somar tudo e elevar ao quadrado dá 1225.
  • A soma dos produtos não é o produto das somas. Multiplicar nota por peso, par a par, e somar dá 75. Multiplicar as duas somas dá 350.
Tabela com cinco comparações do somatório: três iguais (70 e 70, 45 e 45, 15 e 15) e duas diferentes (255 e 1225, 75 e 350)
Três igualdades e duas diferenças, todas medidas no programa do artigo.

Sacou? Só a constante pode sair do somatório. O que depende do índice fica dentro.

Por que a soma dos desvios em relação à média dá zero?

Desvio é a diferença entre um valor e a média. Para as notas, com média 7, os desvios são 0, −2, 1, −1 e 2. Somando: zero. É a última linha do quarto bloco da saída.

Não é coincidência, e as propriedades mostram por quê. O somatório de (xi − média) se separa em dois: o somatório de xi, que é 35, menos o somatório da média. A média é uma constante, então o somatório dela é n vezes a média: 5 × 7 = 35. Sobra 35 − 35 = 0. Como a média é justamente a soma dividida por n, essa conta fecha em zero para qualquer conjunto de dados.

Quem diria… Os desvios positivos e os negativos sempre se cancelam. É por isso que a soma dos desvios não serve para medir o quanto os dados se espalham.

Existe atalho para somar de 1 até n?

Existe. A soma dos números inteiros de 1 até n é n × (n + 1) ÷ 2. O programa somou de 1 até 10, até 100 e até 1000 com um laço e comparou com a fórmula: 55, 5050 e 500500, iguais nas duas colunas.

Essa soma aparece muito em programação. Quando um laço fica dentro de outro e o de dentro dá n − 1 voltas, depois n − 2, e assim até 0, o total de passos é a soma de 1 até n − 1, que pela fórmula é (n − 1) × n ÷ 2. Com n = 500, dá 124.750.

O que é um somatório duplo?

É um somatório dentro de outro, usado para somar uma tabela inteira. São dois índices: i percorre as linhas e j percorre as colunas. No programa, a tabela vendas tem 2 linhas e 3 colunas, como as matrizes que você já conhece. O laço de dentro soma uma linha (12 e 9), e o de fora junta os totais das linhas: 21.

A ordem pode ser trocada. Somando primeiro cada coluna, os totais são 5, 7 e 9, e o total geral é o mesmo 21.

Aí você pergunta: e se a lista estiver vazia?

Um somatório sem nenhuma parcela vale zero, por definição. As funções prontas seguem a regra: no teste, sum([]) devolveu 0 no Python e array_sum([]) devolveu 0 no PHP. Combina com o acumulador: se o laço não dá nenhuma volta, a variável continua com o zero do começo.

ATENÇÃO: cuidado ao calcular a média logo depois. Com n = 0, a conta vira uma divisão por zero.

Quais são os erros mais comuns com somatório?

  • Esquecer de criar o acumulador com zero antes do laço. No Python, usar total = total + 1 sem ter criado total interrompe o programa com NameError: name ‘total’ is not defined.
  • Zerar o acumulador dentro do laço. Cada volta apaga a anterior. Com as cinco notas, o resultado seria 9, a última parcela.
  • Confundir a soma dos quadrados com o quadrado da soma. 255 não é 1225.
  • Tirar do somatório algo que depende do índice. Só constante sai.
  • Errar os limites. Para somar de 1 até 10 no Python, range(10) vai de 0 até 9 e dá 45. O certo é range(1, 11), que dá 55.
  • Somar texto com número. No Python, sum([7, 5, ‘8’]) interrompe o programa com TypeError: unsupported operand type(s) for +: ‘int’ and ‘str’. No PHP 8.3, array_sum([7, 5, “oito”]) emite o aviso “Addition is not supported on type string” e devolve 12.
  • Esperar resultado exato com números com vírgula. Somando 0.1 dez vezes em um laço, o Python mostrou 0.9999999999999999, e a comparação com 1.0 deu falso nas três linguagens. A função sum do Python devolveu 1.0 no mesmo teste, porque desde a versão 3.12 ela usa um algoritmo mais preciso para esse tipo de número.

Agora é com você!

No papel:

  • Escreva parcela por parcela e calcule o somatório de 3 × i, com i de 1 até 4.
  • Para os valores 2, 4, 6 e 8, calcule a soma, a soma dos quadrados, o quadrado da soma e a soma dos desvios em relação à média.
  • Use a fórmula para achar a soma de 1 até 200.

No computador:

  • Altere o programa para somar apenas as notas maiores que 6.
  • Faça o somatório duplo somar por colunas e confira se o total geral continua 21.
  • Escreva um laço que some os quadrados dos números de 1 até 10.

Tente sozinho, sem pedir a resposta pronta para ninguém, nem para a IA!

Até o próximo artigo!

Confiança Sempre!!!

Fontes:

Sobre quem escreve

Walmir Silva

Olá! Sou Walmir, engenheiro de software com MBA em Engenharia de Software e o cérebro por trás do GrowthCode e autor do livro "Além do Código".

Se você acha que programação é apenas sobre escrever código, prepare-se para expandir seus horizontes. Aqui, nós vamos além do código e exploramos as interseções fascinantes entre tecnologia, negócios, artes e filosofia.

Você está em busca de crescimento na carreira? Quer se destacar em um mercado competitivo? Almeja uma vida mais rica em conhecimento e realização? Então você chegou ao lugar certo. No GrowthCode, oferecemos insights profundos, estratégias comprovadas e um toque de sabedoria filosófica para catalisar seu crescimento pessoal e profissional.

Ver todos os artigos →

Continue a conversa

Compartilhe sua perspectiva

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Encontre sua próxima resposta

O que você quer aprender?

Preferências de cookies

Os cookies opcionais começam desligados. Você pode mudar a escolha a qualquer momento por esta tela.

NecessáriosSempre ativos

Guardam a sua escolha de cookies e mantêm o site funcionando. Não são usados para publicidade.

Contam visitas e mostram como o site é usado: Google Analytics e Microsoft Clarity, carregados pelo Google Tag Manager. Como esse contêiner também carrega tags de publicidade, as estatísticas só são ativadas junto com Publicidade e marketing.

Exibem anúncios do Google AdSense e medem campanhas e e-mails: pixels da Meta e do TikTok e o Mautic.

Permite que o Google escolha anúncios com base nos seus interesses. Desligado, os anúncios aparecem sem personalização. Depende de Publicidade e marketing.

Também é possível bloquear cookies nas configurações do navegador. Detalhes na Política de privacidade.