Neste artigo
- Como funciona a potenciação?
- Como calcular uma potência com um laço de repetição?
- Aí você pergunta: e o expoente 0 e o expoente 1?
- Preciso escrever o laço toda vez?
- O que é crescimento exponencial?
- Onde o programador encontra as potências de 2?
- Aí você pergunta: e o caminho de volta?
- Quais são os erros mais comuns com potências?
- Agora é com você!
Potenciação é a multiplicação de fatores iguais: o mesmo número, multiplicado por ele mesmo várias vezes. O número que se repete é a base, e a quantidade de vezes em que ele aparece é o expoente.
No artigo sobre os laços de repetição, você fez o computador repetir uma soma. Hoje o laço repete uma multiplicação, e o resultado cresce de um jeito que surpreende. Se as palavras potência e exponencial lembram uma aula difícil da escola, calma! Você só precisa de uma ideia: multiplicar pelo mesmo número, de novo e de novo. O resto deste artigo sai dela, e o logaritmo, que vem em seguida, também.
Pense em uma folha de papel. Dobre ao meio: são 2 camadas. Dobre de novo: 4. Mais uma vez: 8. Repare que você não ganhou 2 camadas a cada dobra. A quantidade inteira dobrou! Cada dobra multiplica o número de camadas por 2.

Como funciona a potenciação?
Depois de três dobras, a conta das camadas é 2 × 2 × 2 = 8. São três fatores iguais a 2. A potenciação é só um jeito curto de escrever essa conta:
- Base: o número que se repete. Aqui, o 2.
- Expoente: quantas vezes a base aparece na multiplicação. Aqui, o 3.
- Potência: o resultado. Aqui, o 8.
Na matemática, escreve-se 23 = 8, com o expoente pequeno e no alto, e lê-se “2 elevado a 3”. Não se assuste com a notação: ela diz apenas “multiplique o 2 por ele mesmo, usando três fatores”.
ATENÇÃO: 23 não é 2 × 3. O primeiro é 2 × 2 × 2, que dá 8. O segundo dá 6. E a ordem importa: 23 é 8, mas 32 é 3 × 3, que dá 9. Sacou?

Como calcular uma potência com um laço de repetição?
Para o programador, a potência é um laço que multiplica. Começa-se com 1 e multiplica-se pela base uma vez a cada volta. O expoente diz quantas voltas dar. Veja em Python:
# Potência calculada com um laço que multiplica
def potencia(base, expoente):
resultado = 1
for volta in range(expoente):
resultado = resultado * base # multiplica pela base mais uma vez
return resultado
for expoente in range(0, 11):
print("2 elevado a", expoente, "=", potencia(2, expoente))
Em PHP:
<?php
// Potência calculada com um laço que multiplica
function potencia($base, $expoente) {
$resultado = 1;
for ($volta = 0; $volta < $expoente; $volta++) {
$resultado = $resultado * $base; // multiplica pela base mais uma vez
}
return $resultado;
}
for ($expoente = 0; $expoente <= 10; $expoente++) {
echo "2 elevado a $expoente = " . potencia(2, $expoente) . "\n";
}
Em C:
// Potência calculada com um laço que multiplica
#include <stdio.h>
int potencia(int base, int expoente) {
int resultado = 1;
for (int volta = 0; volta < expoente; volta++) {
resultado = resultado * base; // multiplica pela base mais uma vez
}
return resultado;
}
int main(void) {
for (int expoente = 0; expoente <= 10; expoente++) {
printf("2 elevado a %d = %d\n", expoente, potencia(2, expoente));
}
return 0;
}
As três linguagens mostraram a mesma saída:
2 elevado a 0 = 1 2 elevado a 1 = 2 2 elevado a 2 = 4 2 elevado a 3 = 8 2 elevado a 4 = 16 2 elevado a 5 = 32 2 elevado a 6 = 64 2 elevado a 7 = 128 2 elevado a 8 = 256 2 elevado a 9 = 512 2 elevado a 10 = 1024
Foque no conceito, e não na linguagem! Nas três, a função tem a mesma forma: uma variável que começa em 1 e um laço que a multiplica pela base. Essa saída é a tabela das potências de 2. Guarde essa tabela: ela reaparece neste artigo e no próximo.
| Expoente | Multiplicação | Resultado |
|---|---|---|
| 0 | nenhuma | 1 |
| 1 | 2 | 2 |
| 2 | 2 × 2 | 4 |
| 3 | 2 × 2 × 2 | 8 |
| 4 | 2 × 2 × 2 × 2 | 16 |
| 5 | 2 × 2 × 2 × 2 × 2 | 32 |
| 10 | dez fatores iguais a 2 | 1.024 |
Aí você pergunta: e o expoente 0 e o expoente 1?
Olhe as duas primeiras linhas da saída. Com expoente 1, a base aparece uma vez só, e o resultado é a própria base: 21 = 2. Com expoente 0, o laço não dá nenhuma volta, e a função devolve o valor inicial: 20 = 1.
Parece estranho, mas a tabela mostra por que a matemática fez essa escolha. Lendo de baixo para cima, cada linha é a anterior dividida por 2: 8, 4, 2… e o próximo é 1. Com o 1 na linha do expoente 0, o padrão continua valendo. É uma convenção, feita para que as regras das potências não quebrem.
Preciso escrever o laço toda vez?
No dia a dia, não. Python e PHP têm um operador de potência, o **. A linguagem C não tem operador para isso: usa-se a função pow, da biblioteca math.h, que trabalha com números reais. Em Python:
# O operador de potência e a pegadinha do ^
print("2 ** 10 =", 2 ** 10)
print("3 ** 2 =", 3 ** 2)
print("2 ** 3 =", 2 ** 3)
print("7 ** 1 =", 7 ** 1)
print("7 ** 0 =", 7 ** 0)
print("2 ^ 10 =", 2 ^ 10) # ATENÇÃO: ^ não é potência
Em PHP:
<?php // O operador de potência e a pegadinha do ^ echo "2 ** 10 = " . (2 ** 10) . "\n"; echo "3 ** 2 = " . (3 ** 2) . "\n"; echo "2 ** 3 = " . (2 ** 3) . "\n"; echo "7 ** 1 = " . (7 ** 1) . "\n"; echo "7 ** 0 = " . (7 ** 0) . "\n"; echo "2 ^ 10 = " . (2 ^ 10) . "\n"; // ATENÇÃO: ^ não é potência
Em C:
// A função pow e a pegadinha do ^
#include <stdio.h>
#include <math.h>
int main(void) {
printf("pow(2, 10) = %.0f\n", pow(2, 10));
printf("pow(3, 2) = %.0f\n", pow(3, 2));
printf("pow(2, 3) = %.0f\n", pow(2, 3));
printf("pow(7, 1) = %.0f\n", pow(7, 1));
printf("pow(7, 0) = %.0f\n", pow(7, 0));
printf("2 ^ 10 = %d\n", 2 ^ 10); // ATENÇÃO: ^ não é potência
return 0;
}
Saída em Python e em PHP:
2 ** 10 = 1024 3 ** 2 = 9 2 ** 3 = 8 7 ** 1 = 7 7 ** 0 = 1 2 ^ 10 = 8
Saída em C:
pow(2, 10) = 1024 pow(3, 2) = 9 pow(2, 3) = 8 pow(7, 1) = 7 pow(7, 0) = 1 2 ^ 10 = 8
ATENÇÃO: repare na última linha das saídas. Em texto digitado, é comum escrever 2^10 para “2 elevado a 10”. No código, não! Nas três linguagens, 2 ^ 10 respondeu 8. Em Python, o ^ é outro operador, o ou exclusivo, que trabalha com os bits dos números. Em C, o compilador GCC avisou do engano na hora de compilar:
alg_operador.c:11:31: warning: result of '2^10' is 8; did you mean '1 << 10' (1024)? [-Wxor-used-as-pow]
O que é crescimento exponencial?
É o crescimento do valor que é multiplicado pelo mesmo número a cada passo. Quando o valor recebe a mesma soma a cada passo, o crescimento se chama linear. A diferença entre os dois é enorme, e o programa abaixo mostra: uma variável ganha 2 a cada volta, e a outra é multiplicada por 2.
# Somar 2 a cada volta ou multiplicar por 2 a cada volta?
somando = 0
dobrando = 1
print("volta | somando 2 | multiplicando por 2")
for volta in range(1, 11):
somando = somando + 2
dobrando = dobrando * 2
print(volta, "|", somando, "|", dobrando)
Saída:
volta | somando 2 | multiplicando por 2 1 | 2 | 2 2 | 4 | 4 3 | 6 | 8 4 | 8 | 16 5 | 10 | 32 6 | 12 | 64 7 | 14 | 128 8 | 16 | 256 9 | 18 | 512 10 | 20 | 1024

Nas duas primeiras voltas, os dois valores são iguais. Na volta 10, um está em 20, e o outro, em 1.024. Vou repetir porque é importante: no crescimento linear, soma-se a mesma quantidade a cada passo; no exponencial, multiplica-se pelo mesmo fator a cada passo. É por isso que o exponencial começa devagar e depois dispara.
O nome vem do expoente. O número de voltas, que é o que muda, fica no expoente da potência: depois de n voltas, o valor é 2n.
Ver a animação do valor dobrando a cada volta

Onde o programador encontra as potências de 2?
Em quase todo canto! Dois exemplos:
- Bits. Um bit guarda 2 valores, 0 ou 1. Cada bit a mais dobra a quantidade de combinações. Por isso, com n bits é possível representar 2n valores diferentes: 8 bits, um byte, dão 256.
- Busca binária. Cada pergunta da busca binária corta as possibilidades pela metade, que é o caminho inverso de dobrar. Como 220 passa de 1 milhão, 20 perguntas bastam para achar um valor entre 1 milhão.
# Quantos valores cabem em n bits? 2 elevado a n
for bits in [1, 2, 3, 8, 16, 32]:
print(bits, "bits:", 2 ** bits, "valores")
print("2 elevado a 20 =", 2 ** 20)
Saída:
1 bits: 2 valores 2 bits: 4 valores 3 bits: 8 valores 8 bits: 256 valores 16 bits: 65536 valores 32 bits: 4294967296 valores 2 elevado a 20 = 1048576
Com 32 bits, já são mais de 4 bilhões de valores. E bastaram 32 multiplicações por 2 para chegar lá!
Aí você pergunta: e o caminho de volta?
Até aqui, você sabia o número de dobras e queria as camadas. A pergunta ao contrário também existe: se a folha dobrada tem 1.024 camadas, quantas dobras foram? Dá para responder com a tabela, procurando o 1.024 na coluna dos resultados: 10. E dá para responder com um laço que conta as dobras até chegar ao alvo:
# O caminho de volta: quantas dobras até chegar ao alvo?
def contar_dobras(alvo):
camadas = 1
dobras = 0
while camadas < alvo:
camadas = camadas * 2
dobras = dobras + 1
return dobras
print("até 8 camadas:", contar_dobras(8), "dobras")
print("até 1024 camadas:", contar_dobras(1024), "dobras")
print("até 1000000 camadas:", contar_dobras(1000000), "dobras")
Saída:
até 8 camadas: 3 dobras até 1024 camadas: 10 dobras até 1000000 camadas: 20 dobras
O 1 milhão não é uma potência exata de 2, e por isso a função devolveu 20: é o número de dobras necessário para chegar a 1 milhão ou passar dele.
Essa pergunta ao contrário tem nome: logaritmo. O logaritmo de 1.024 na base 2 é 10, porque 2 elevado a 10 dá 1.024. Não tem mistério: é a mesma tabela, lida da direita para a esquerda. É o assunto do próximo artigo.
Quais são os erros mais comuns com potências?
- Confundir potência com multiplicação. 23 é 8, e não 6.
- Trocar a base e o expoente. 23 é 8, e 32 é 9.
- Usar o ^ no código. Em Python, PHP e C, ele não calcula potência.
- Começar o laço com 0. Zero vezes qualquer número dá zero, e o resultado nunca sai do lugar. O valor inicial é 1.
- Esquecer o expoente 0. A base 2 elevada a 0 dá 1, e o mesmo vale para as outras bases positivas.
- Achar que dobrar é somar 2. Somando, o valor cresce de 2 em 2. Dobrando, ele dispara.
Agora é com você!
No papel:
- Quanto é 26? E 27? Use a tabela e depois confira multiplicando.
- Quanto é 34? Escreva a multiplicação antes de fazer a conta.
- Uma folha foi dobrada e ficou com 64 camadas. Quantas dobras foram?
- Quantos valores diferentes cabem em 10 bits?
No computador:
- Use a função potencia para mostrar a tabela das potências de 3, do expoente 0 ao 5.
- Mude a função para contar quantas multiplicações ela fez.
- Escreva um programa que descobre a primeira volta em que o valor que dobra passa de 1 milhão.
Tente sozinho, sem pedir a resposta pronta para ninguém, nem para a IA!
Você viu que multiplicar sempre pelo mesmo número faz o valor disparar, e que a tabela das potências pode ser lida ao contrário. No próximo artigo, essa leitura ao contrário ganha nome e uso: o logaritmo, que explica por que a busca binária é tão rápida. Até lá!
Confiança Sempre!!!
Fontes:
- Instituto Federal do Rio Grande do Norte, Matemática I, aula 1, Potenciação com expoentes inteiros, com a definição de potência como o produto de n fatores iguais e os nomes base e expoente (notas de aula).
- Universidade Federal do Rio Grande do Norte, Instituto Metrópole Digital, Matemática Aplicada, Potenciação, com a potência como multiplicação de n fatores iguais à base, o caso do expoente 1 e as formas de ler uma potência (PDF).
- Revista de Ciência Elementar, Potências, artigo da Faculdade de Ciências da Universidade do Porto, com a definição para expoente inteiro positivo e a convenção de que a potência de expoente zero é igual a 1 (PDF).
- OpenStax, Pré-cálculo, seção 4.1, Funções exponenciais, com a comparação entre o crescimento linear, que soma a mesma quantidade a cada passo, e o exponencial, que multiplica pelo mesmo fator, e a função exponencial como a que tem a variável no expoente (tradução na LibreTexts).
- University of Toronto, ECE243, Computer Organization, aula sobre representações, com a regra de que N bits representam até 2 elevado a N coisas diferentes, e 8 bits, 256 (em inglês).
- Unicamp, Instituto de Computação, MC404, Representação de Informações no Computador, com os bits como dígitos binários e o exemplo de 3 bits para 8 números distintos (PDF, slides de aula).
- Instituto Federal do Rio Grande do Norte, Informática, aula 2, Binário e unidades de medida, com o byte como sequência de 8 bits e as 256 informações distintas que ele representa (slides de aula).
- Kansas State University, Introduction to Python, New Operators, com o operador ** de exponenciação e o aviso de que o ^ representa o ou exclusivo bit a bit (em inglês).
- Manual do PHP, Operadores Aritméticos, com o operador ** de exponenciação na lista de operadores.
- cppreference, pow, powf, powl, com a função pow, do cabeçalho math.h, que calcula a base elevada ao expoente com números de ponto flutuante (em inglês).
- Universidade Federal de São Carlos, Algoritmos e Estruturas de Dados 1, aula 1, com a definição de logaritmo na base 2 (PDF).
- Os exemplos foram executados em Python 3.13, PHP 8.3 e GCC 13.

Continue a conversa