Neste artigo
- O que é um produtório?
- Como ler uma expressão com Σ ou com ∏?
- Como calcular um produtório em Python, PHP e C?
- Quais são as propriedades do produtório?
- O que o fatorial tem a ver com o produtório?
- Onde mais o produtório aparece?
- Aí você pergunta: e se a lista estiver vazia?
- Aí você pergunta: dá para trocar um produtório por um somatório?
- Quais são os erros mais comuns com produtório?
- Agora é com você!
Produtório é a multiplicação de uma sequência de valores, escrita de forma abreviada com a letra grega pi maiúscula (∏). Também é chamado de produtória. Em vez de escrever x1 × x2 × x3 × … × xn, você escreve um símbolo só, com três informações: o que multiplicar, onde começar e onde parar.
No artigo sobre o somatório, vimos como o sigma (Σ) abrevia uma soma comprida. O produtório é o irmão dele: a mesma estrutura, com a multiplicação no lugar da soma. E, se você já escreveu um laço de repetição que multiplica uma variável a cada volta, já programou um.
Pense em uma lanchonete. Para montar o combo, você escolhe 1 entre 3 pães, depois 1 entre 4 recheios e, por fim, 1 entre 2 bebidas. De quantos jeitos dá para montar? Para cada pão há 4 recheios: 3 × 4 = 12. Para cada um desses 12 há 2 bebidas: 12 × 2 = 24 combos. O produtório é o jeito de escrever “multiplique todas as quantidades, da primeira à última” sem listar uma por uma.

O que é um produtório?
É uma multiplicação escrita com quatro partes:
- O pi maiúsculo (∏): a ordem de multiplicar.
- O índice: a letra que conta os fatores. Aqui, i.
- Os limites: embaixo do pi, 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 pi, o que entra na multiplicação para cada valor do índice.

Tome as quantidades da lanchonete: 3, 4 e 2. Chamando a primeira de x1, a segunda de x2 e a terceira de x3, o produtório das três fica assim:
3 ∏ x_i = x_1 × x_2 × x_3 = 3 × 4 × 2 = 24 i=1
ATENÇÃO: o ∏ é a letra pi maiúscula. Não confunda com o π, a letra pi minúscula, que representa um número: no Python, math.pi devolve 3.141592653589793. São dois símbolos diferentes, com dois significados diferentes.
Como ler uma expressão com Σ ou com ∏?
Se esses símbolos assustam você no meio de uma fórmula, calma! Os dois são lidos do mesmo jeito, em cinco passos:
- Olhe embaixo do símbolo. Ali estão a letra do índice e o valor em que ela começa.
- Olhe em cima. Ali está o valor em que o índice termina.
- Olhe à direita. Ali está o termo geral, a conta que será repetida.
- Troque o índice por cada número inteiro, do limite de baixo até o de cima, e anote o resultado de cada troca.
- Junte os resultados. Com + se o símbolo for Σ. Com × se for ∏.
Em voz alta, a leitura segue a mesma ordem. O somatório abaixo se lê “soma de i, para i de 1 até 4”. Trocando uma palavra, o produtório se lê “produto de i, para i de 1 até 4”.
4 Σ i = 1 + 2 + 3 + 4 = 10 i=1 4 ∏ i = 1 × 2 × 3 × 4 = 24 i=1

Quando o termo geral é uma conta, a troca do quarto passo acontece dentro dela. Veja com o termo geral 2 × k, com k de 1 até 3:
3 ∏ (2 × k) = (2 × 1) × (2 × 2) × (2 × 3) = 2 × 4 × 6 = 48 k=1
Repare que o índice agora é k, e não i. A letra do índice não muda nada: trocar uma pela outra dá o mesmo resultado.
E quando o termo geral é xi? Nesse caso o índice não entra em uma conta: ele aponta uma posição em uma lista de valores. O x1 é o primeiro valor, o x2 é o segundo, e assim por diante. É o caso das quantidades da lanchonete.
Para o programador, cada parte da notação tem um par no laço de repetição:
| Na expressão | No programa |
|---|---|
| O índice (i, k…) | A variável que controla o laço |
| Os limites | Onde o laço começa e onde termina |
| O termo geral | A conta feita em cada volta |
| O Σ | Um acumulador que começa em 0 e soma |
| O ∏ | Um acumulador que começa em 1 e multiplica |
Ou seja: quem sabe escrever um laço já sabe ler um somatório e um produtório!
Como calcular um produtório em Python, PHP e C?
O produtório vira um laço com um acumulador, como no somatório. A diferença está no começo: o acumulador parte de 1, e não de 0, e é multiplicado por um fator a cada volta. O programa abaixo faz isso com as quantidades da lanchonete e depois testa, com números, cada propriedade que vem a seguir.
Python:
# Produtório: a multiplicação de uma lista de valores, escrita com a letra pi maiúscula
import math
opcoes = [3, 4, 2]
n = len(opcoes)
# o produtório é um laço com um acumulador que começa em 1
produto = 1
for i in range(n):
produto = produto * opcoes[i]
print("i = %d x = %d produto parcial = %d" % (i + 1, opcoes[i], produto))
print()
print("produto dos valores:", produto)
print("com uma função:", math.prod(opcoes))
# constante multiplicando: sai do produtório elevada a n
produto_dobro = 1
for x in opcoes:
produto_dobro = produto_dobro * (2 * x)
print()
print("produto de 2x: %d 2 elevado a 3, vezes o produto: %d" % (produto_dobro, 2 ** n * produto))
# produtório de uma constante: a constante elevada a n
produto_const = 1
for i in range(n):
produto_const = produto_const * 10
print("produto de 10, três vezes: %d 10 elevado a 3: %d" % (produto_const, 10 ** n))
# produto de duas listas, par a par: pode separar em dois produtórios
outros = [2, 1, 3]
produto_juntos = 1
produto_outros = 1
for i in range(n):
produto_juntos = produto_juntos * (opcoes[i] * outros[i])
produto_outros = produto_outros * outros[i]
print("produto de (x × y): %d produto de x vezes produto de y: %d" % (produto_juntos, produto * produto_outros))
# o produto das somas não é a soma dos produtos
produto_somas = 1
for i in range(n):
produto_somas = produto_somas * (opcoes[i] + outros[i])
print()
print("produto de (x + y): %d produto de x mais produto de y: %d" % (produto_somas, produto + produto_outros))
# um fator igual a zero zera o produto inteiro
com_zero = [3, 4, 0, 2]
produto_zero = 1
for x in com_zero:
produto_zero = produto_zero * x
print("produto com um fator igual a zero:", produto_zero)
# produto de 1 até n: o fatorial
print()
for limite in [5, 10, 20]:
total = 1
for i in range(1, limite + 1):
total = total * i
print("produto de 1 até %d: %d" % (limite, total))
# o logaritmo transforma o produtório em somatório
soma_logs = 0.0
for x in opcoes:
soma_logs = soma_logs + math.log10(x)
print()
print("logaritmo do produto: %.4f soma dos logaritmos: %.4f" % (math.log10(produto), soma_logs))
PHP:
<?php
// Produtório: a multiplicação de uma lista de valores, escrita com a letra pi maiúscula
$opcoes = [3, 4, 2];
$n = count($opcoes);
// o produtório é um laço com um acumulador que começa em 1
$produto = 1;
for ($i = 0; $i < $n; $i++) {
$produto = $produto * $opcoes[$i];
printf("i = %d x = %d produto parcial = %d\n", $i + 1, $opcoes[$i], $produto);
}
echo "\nproduto dos valores: $produto\n";
echo "com uma função: " . array_product($opcoes) . "\n";
// constante multiplicando: sai do produtório elevada a n
$produto_dobro = 1;
foreach ($opcoes as $x) {
$produto_dobro = $produto_dobro * (2 * $x);
}
printf("\nproduto de 2x: %d 2 elevado a 3, vezes o produto: %d\n", $produto_dobro, 2 ** $n * $produto);
// produtório de uma constante: a constante elevada a n
$produto_const = 1;
for ($i = 0; $i < $n; $i++) {
$produto_const = $produto_const * 10;
}
printf("produto de 10, três vezes: %d 10 elevado a 3: %d\n", $produto_const, 10 ** $n);
// produto de duas listas, par a par: pode separar em dois produtórios
$outros = [2, 1, 3];
$produto_juntos = 1;
$produto_outros = 1;
for ($i = 0; $i < $n; $i++) {
$produto_juntos = $produto_juntos * ($opcoes[$i] * $outros[$i]);
$produto_outros = $produto_outros * $outros[$i];
}
printf("produto de (x × y): %d produto de x vezes produto de y: %d\n", $produto_juntos, $produto * $produto_outros);
// o produto das somas não é a soma dos produtos
$produto_somas = 1;
for ($i = 0; $i < $n; $i++) {
$produto_somas = $produto_somas * ($opcoes[$i] + $outros[$i]);
}
printf("\nproduto de (x + y): %d produto de x mais produto de y: %d\n", $produto_somas, $produto + $produto_outros);
// um fator igual a zero zera o produto inteiro
$com_zero = [3, 4, 0, 2];
$produto_zero = 1;
foreach ($com_zero as $x) {
$produto_zero = $produto_zero * $x;
}
echo "produto com um fator igual a zero: $produto_zero\n";
// produto de 1 até n: o fatorial
echo "\n";
foreach ([5, 10, 20] as $limite) {
$total = 1;
for ($i = 1; $i <= $limite; $i++) {
$total = $total * $i;
}
printf("produto de 1 até %d: %d\n", $limite, $total);
}
// o logaritmo transforma o produtório em somatório
$soma_logs = 0.0;
foreach ($opcoes as $x) {
$soma_logs = $soma_logs + log10($x);
}
printf("\nlogaritmo do produto: %.4f soma dos logaritmos: %.4f\n", log10($produto), $soma_logs);
C:
/* Produtório: a multiplicação de uma lista de valores, escrita com a letra pi maiúscula */
#include <stdio.h>
#include <math.h>
/* função que multiplica os n primeiros elementos de um vetor */
long long multiplicar(const int v[], int n) {
long long total = 1;
for (int i = 0; i < n; i++) {
total = total * v[i];
}
return total;
}
/* função que calcula a base elevada ao expoente com um laço */
long long potencia(int base, int expoente) {
long long resultado = 1;
for (int i = 0; i < expoente; i++) {
resultado = resultado * base;
}
return resultado;
}
int main(void) {
int opcoes[] = {3, 4, 2};
int n = 3;
/* o produtório é um laço com um acumulador que começa em 1 */
long long produto = 1;
for (int i = 0; i < n; i++) {
produto = produto * opcoes[i];
printf("i = %d x = %d produto parcial = %lld\n", i + 1, opcoes[i], produto);
}
printf("\nproduto dos valores: %lld\n", produto);
printf("com uma função: %lld\n", multiplicar(opcoes, n));
/* constante multiplicando: sai do produtório elevada a n */
long long produto_dobro = 1;
for (int i = 0; i < n; i++) {
produto_dobro = produto_dobro * (2 * opcoes[i]);
}
printf("\nproduto de 2x: %lld 2 elevado a 3, vezes o produto: %lld\n", produto_dobro, potencia(2, n) * produto);
/* produtório de uma constante: a constante elevada a n */
long long produto_const = 1;
for (int i = 0; i < n; i++) {
produto_const = produto_const * 10;
}
printf("produto de 10, três vezes: %lld 10 elevado a 3: %lld\n", produto_const, potencia(10, n));
/* produto de duas listas, par a par: pode separar em dois produtórios */
int outros[] = {2, 1, 3};
long long produto_juntos = 1, produto_outros = 1;
for (int i = 0; i < n; i++) {
produto_juntos = produto_juntos * (opcoes[i] * outros[i]);
produto_outros = produto_outros * outros[i];
}
printf("produto de (x × y): %lld produto de x vezes produto de y: %lld\n", produto_juntos, produto * produto_outros);
/* o produto das somas não é a soma dos produtos */
long long produto_somas = 1;
for (int i = 0; i < n; i++) {
produto_somas = produto_somas * (opcoes[i] + outros[i]);
}
printf("\nproduto de (x + y): %lld produto de x mais produto de y: %lld\n", produto_somas, produto + produto_outros);
/* um fator igual a zero zera o produto inteiro */
int com_zero[] = {3, 4, 0, 2};
printf("produto com um fator igual a zero: %lld\n", multiplicar(com_zero, 4));
/* produto de 1 até n: o fatorial */
int limites[] = {5, 10, 20};
printf("\n");
for (int t = 0; t < 3; t++) {
int limite = limites[t];
long long total = 1;
for (int i = 1; i <= limite; i++) {
total = total * i;
}
printf("produto de 1 até %d: %lld\n", limite, total);
}
/* o logaritmo transforma o produtório em somatório */
double soma_logs = 0.0;
for (int i = 0; i < n; i++) {
soma_logs = soma_logs + log10(opcoes[i]);
}
printf("\nlogaritmo do produto: %.4f soma dos logaritmos: %.4f\n", log10((double) produto), soma_logs);
return 0;
}
Saída:
i = 1 x = 3 produto parcial = 3 i = 2 x = 4 produto parcial = 12 i = 3 x = 2 produto parcial = 24 produto dos valores: 24 com uma função: 24 produto de 2x: 192 2 elevado a 3, vezes o produto: 192 produto de 10, três vezes: 1000 10 elevado a 3: 1000 produto de (x × y): 144 produto de x vezes produto de y: 144 produto de (x + y): 125 produto de x mais produto de y: 30 produto com um fator igual a zero: 0 produto de 1 até 5: 120 produto de 1 até 10: 3628800 produto de 1 até 20: 2432902008176640000 logaritmo do produto: 1.3802 soma dos logaritmos: 1.3802
O Python tem a função math.prod, e o PHP tem a array_product, que fazem o laço por você. No programa em C, a função multiplicar 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 produtó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 multiplicando as três quantidades

Aí você pergunta: por que o acumulador começa em 1? Porque multiplicar por 1 não muda o valor, assim como somar 0 não muda. Se ele começasse em 0, toda multiplicação daria 0: no teste, o laço com as três quantidades terminou em 0, e não em 24.
Quais são as propriedades do produtó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 produtório, elevada a n. Multiplicar o dobro de cada quantidade é o mesmo que multiplicar o produto por 2 × 2 × 2, um 2 para cada fator: 192 e 192.
- Produto de duas listas separa em dois produtórios. Multiplicar x por y, par a par, é o mesmo que multiplicar os x, multiplicar os y e juntar os dois resultados: 144 e 144.
- Produtório de uma constante é a constante elevada a n. Multiplicar o número 10 três vezes dá 10 elevado a 3: 1000 e 1000. Uma potência é um produtório em que todos os fatores são iguais.
E duas coisas para guardar:
- O produto das somas não é a soma dos produtos. Somar x com y, par a par, e multiplicar tudo dá 125. Multiplicar cada lista e somar os dois resultados dá 30.
- Um fator igual a zero zera tudo. Com as quantidades 3, 4, 0 e 2, o produto é 0.
Sacou? No somatório, a constante sai uma vez só. No produtório, ela sai uma vez para cada fator.
Lado a lado, os dois símbolos ficam assim:
| Comparação | Somatório (Σ) | Produtório (∏) |
|---|---|---|
| Operação | Soma | Multiplicação |
| O acumulador começa em | 0 | 1 |
| Sem nenhum valor, o resultado é | 0 | 1 |
| Constante c multiplicando o termo geral | Sai como c | Sai como c elevado a n |
| Termo geral igual a uma constante c | n × c | c elevado a n |
| Função pronta no Python | sum | math.prod |
| Função pronta no PHP | array_sum | array_product |
O que o fatorial tem a ver com o produtório?
O fatorial de um número n, escrito n!, é o produto dos números inteiros de 1 até n. Em notação de produtório, o termo geral é o próprio índice:
n
n! = ∏ i = 1 × 2 × 3 × ... × n
i=1
O programa calculou três: o produto de 1 até 5 é 120, o de 1 até 10 é 3.628.800, e o de 1 até 20 é 2.432.902.008.176.640.000. Repare como o resultado dispara! O limite só dobrou de 10 para 20, e o produto passou de 7 para 19 dígitos.
O fatorial será o assunto de um dos próximos artigos.
Onde mais o produtório aparece?
- Na contagem. A conta dos combos da lanchonete é um produtório: as quantidades de opções de cada etapa, multiplicadas.
- Na média geométrica. Ela é a raiz de ordem n do produto dos n valores. Para 2, 4 e 8, o produto é 64, e a raiz cúbica de 64 é 4, porque 4 × 4 × 4 = 64. As outras médias estão no artigo sobre as médias estatísticas.
- Na probabilidade. Quando dois eventos são independentes, a probabilidade de os dois acontecerem é o produto das probabilidades de cada um. Se cada uma for 0,5, a dos dois juntos é 0,5 × 0,5 = 0,25.
Aí você pergunta: e se a lista estiver vazia?
Um produtório sem nenhum fator vale 1, e não 0, por definição. As funções prontas seguem a regra: no teste, math.prod([]) devolveu 1 no Python e array_product([]) devolveu 1 no PHP. Combina com o acumulador: se o laço não dá nenhuma volta, a variável continua com o 1 do começo.
É a mesma ideia do expoente zero, do artigo sobre potenciação: nenhuma multiplicação feita, resultado 1. E é por essa regra que o fatorial de 0 vale 1.
Aí você pergunta: dá para trocar um produtório por um somatório?
Dá, com a ajuda do logaritmo. O logaritmo de um produto é igual à soma dos logaritmos dos fatores. Na última linha da saída, o logaritmo de 24 e a soma dos logaritmos de 3, 4 e 2 deram o mesmo número: 1,3802.
Para o programador, essa troca resolve um problema real. O produto de muitos números pequenos, como probabilidades, encolhe tão depressa que deixa de caber em uma variável. No teste, multiplicar 0,1 por ele mesmo 400 vezes deu 0.0 no Python, no PHP e no C. O resultado certo não é zero: é um número com 400 casas depois da vírgula. Somando o logaritmo de 0,1 na base 10 a cada volta, no lugar de multiplicar, o mesmo laço chegou a −400 sem perder nada. Por isso é comum guardar e somar os logaritmos das probabilidades, em vez de multiplicá-las.
Quais são os erros mais comuns com produtório?
- Começar o acumulador com 0. Tudo o que é multiplicado por 0 dá 0. Com as três quantidades, o resultado seria 0, e não 24.
- Esquecer de criar o acumulador antes do laço. No Python, usar total = total * 3 sem ter criado total interrompe o programa com NameError: name ‘total’ is not defined.
- Errar os limites. Para multiplicar de 1 até 5 no Python, range(5) vai de 0 até 4, e o fator 0 zera tudo. O certo é range(1, 6), que dá 120.
- Tirar a constante sem elevar a n. O produto de 2x deu 192, e não 2 × 24 = 48.
- Confundir o produto das somas com a soma dos produtos. 125 não é 30.
- Confundir ∏ com π. O maiúsculo manda multiplicar. O minúsculo é um número.
- Esquecer que o resultado cresce depressa. O produto de 1 até 20 ainda coube em um inteiro de 64 bits nas três linguagens. O de 1 até 21, não: no teste, o Python devolveu 51090942171709440000, o PHP trocou o inteiro por um número com vírgula e mostrou 5.1090942171709E+19, e o C, com uma variável unsigned long long, mostrou 14197454024290336768, um valor errado e sem nenhum aviso.
- Multiplicar texto por número. No Python, math.prod([‘3’, 4]) não deu erro: devolveu o texto ‘3333’, porque multiplicar um texto por 4 repete o texto. No PHP 8.3, array_product([3, “quatro”]) emitiu o aviso “Multiplication is not supported on type string” e devolveu 0.
- Esperar resultado exato com números com vírgula. Multiplicando 0.1 dez vezes em um laço, o Python mostrou 1.0000000000000006e-10, e a comparação com 1e-10 deu falso nas três linguagens.
Agora é com você!
No papel:
- Escreva fator por fator e calcule o produtório de 3 × i, com i de 1 até 3.
- Leia em voz alta e calcule o somatório e o produtório de (i + 1), com i de 1 até 3.
- Para os valores 2, 5 e 10, calcule o produto e o produto do triplo de cada valor. Depois confira a regra da constante.
No computador:
- Altere o programa para multiplicar apenas os valores maiores que 2.
- Escreva um laço que calcule o produto dos números pares de 2 até 10.
- Troque o 20 por 25 no laço do fatorial e compare a saída das três linguagens.
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, Elementos de Matemática Discreta para Computação, de Anamaria Gomide e Jorge Stolfi, seção 9.7, Produtórias, com a definição de produtória, o valor 1 para a produtória vazia e a identidade que transforma uma produtória em somatória de logaritmos (PDF, livro).
- Unicamp, Instituto de Computação, material de aula sobre somatórias e produtórias, com o índice, o termo geral e os limites da notação, os nomes produtória e produtório e a regra de que a produtória sem nenhum fator vale 1, e não zero (PDF, slides de aula).
- Unicamp, Instituto de Computação, material de aula de Matemática Discreta com a definição de fatorial, com o fatorial de n escrito como a produtória de k, com k de 1 até n, e o fatorial de 0 igual a 1 por ser uma produtória vazia (PDF, slides de aula).
- UFMG, Departamento de Ciência da Computação, Matemática Discreta, Funções, Sequências, Somatórios e Produtórios, com a definição de produtório, a troca da letra do índice sem mudar o resultado e a propriedade do produto de dois produtórios, termo a termo (PDF, slides de aula).
- Universidade Federal de Viçosa, Departamento de Estatística, Estatística I, aula 2, com a leitura de um somatório em voz alta e o produtório escrito com a letra pi maiúscula (PDF, slides de aula).
- UFMG, Departamento de Ciência da Computação, Matemática Discreta, Combinatória básica, com a regra do produto: se uma etapa tem p casos e a seguinte tem q, as duas juntas têm p × q (PDF, slides de aula).
- Universidade Federal de Pernambuco, Centro de Informática, Estatística, aula 10, com a média geométrica como a raiz de ordem n do produto dos valores (PDF, slides de aula).
- Universidade Federal do Paraná, CE003, Probabilidade, com a regra de que, para dois eventos independentes, a probabilidade de os dois ocorrerem é o produto das probabilidades (PDF, notas de aula).
- University of Notre Dame, CSE 40657, Natural Language Processing, capítulo 2, com o produto de muitas probabilidades virando um número pequeno demais para o computador e a troca da multiplicação pela soma dos logaritmos (PDF, em inglês).
- Python, documentação oficial, módulo math, prod, com o produto dos elementos a partir de start, que por padrão é 1, e o retorno de start quando não há elementos (em inglês).
- PHP, manual oficial, array_product, com o produto dos valores de um array, o resultado 1 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