Neste artigo
- O que é um somatório?
- Como escrever a média com somatório?
- Como calcular um somatório em Python, PHP e C?
- Quais são as propriedades do somatório?
- Por que a soma dos desvios em relação à média dá zero?
- Existe atalho para somar de 1 até n?
- O que é um somatório duplo?
- Aí você pergunta: e se a lista estiver vazia?
- Quais são os erros mais comuns com somatório?
- 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.

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

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.

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:
- Unicamp, Instituto de Computação, material de aula sobre somatórias, com a forma geral da notação sigma, o índice, o termo geral e os limites, a soma vazia igual a zero, a troca da letra do índice, a distributividade, a associatividade, a soma de 1 até n e as somatórias múltiplas (PDF, slides de aula).
- Sociedade Brasileira de Matemática, Revista Matemática Universitária, Uma introdução a somatórios fracionários, com a notação sigma, a letra grega maiúscula que indica a soma e a regra de incluir os termos cujo índice é um inteiro entre os dois limites, inclusive (PDF, artigo).
- Universidade Federal de Pelotas, Estatística Básica, aula 4, com a média aritmética como soma de todos os valores dividida pelo total de valores e a propriedade de que a soma dos desvios em relação à média é nula (PDF, slides de aula).
- Universidade Federal de Sergipe, CESAD, Probabilidade e Estatística (material do CEDERJ), aula 4, Medidas de dispersão, com a soma dos desvios em relação à média, sempre nula, que por isso não serve para diferenciar conjuntos de dados, e o uso das propriedades de somatório (PDF).
- USP, e-Disciplinas, LCF280, Apontamentos de Medidas de Posição, com a média escrita com somatório e a demonstração de que a soma dos desvios em relação à média é zero (PDF).
- USP, e-Disciplinas, texto de estatística sobre média e medidas de dispersão, com a média escrita com somatório e a observação de que, para qualquer conjunto de dados, a soma dos desvios é igual a zero e por isso não é uma boa medida de dispersão.
- Universidade Federal de Sergipe, CESAD, Estatística e Probabilidade, capítulo 6, Medidas de Posição, com o desvio em relação à média e a propriedade de que a soma algébrica dos desvios é nula (PDF).
- Python, documentação oficial, funções embutidas, sum, com a soma dos itens da esquerda para a direita a partir de start, que por padrão é 0, e a mudança da versão 3.12 na soma de números de ponto flutuante (em inglês).
- PHP, manual oficial, array_sum, com a soma dos valores de um array, o retorno 0 para array vazio e o aviso emitido desde o PHP 8.3 para valores que não podem ser convertidos em número.
- Os exemplos foram executados em Python 3.13, PHP 8.3 e GCC 13.

Continue a conversa