O que é mais rápido: um laço while ou um laço for?

Existe diferença no tempo de processamento utilizando um laço de repetição for ou while. Ou seja, a escolha do laço de repetição impacta no desempenho do código?

Sim, existe diferença, dependendo da linguagem de programação utilizada.

Mostro aqui a diferença nas linguagens de programação C e Python e também aproveito para comentar sobre o processo de avaliar o tempo de execução de um código. No final desse post também trago um vídeo explicativo.

Para isso proponho uma operação bastante simples, que incrementa um contador várias vezes, utilizando os dois laços de repetição. O código é sintetizado na figura a seguir.

Para calcular o tempo de execução de cada trecho de código na linguagem C, utilizei a função clock(), que retorna o número de tiques do relógio. Essa função faz parte da biblioteca time.h. Nas linhas 11 e 15 eu utilizo a função para pegar o tique da CPU naquele instante da execução (imediatamente antes e imediatamente depois do bloco de repetição.

Na linha 16 eu dividi a diferença entre os momentos da execução e dividi pela constante CLOCKS_PER_SEC para obter quanto tempo, em segundos, o programa está em execução. A função clock() retorna um clock_t, que é um valor long int, assim como a constante CLOCKS_PER_SEC. Sendo assim, para fazer essa divisão é preciso fazer um casting (no caso, fiz o casting no numerador).

Veja que, além de executar cada bloco de repetição cem milhões de vezes, fiz isso 10 vezes (pelo while na linha 10).

Código em linguagem C

#include <stdio.h>
#include <time.h>
#define TAM 100000000

int main(void) {
    int i, j=0, cont=0;
    double tempo, total1=0, total2=0;
    clock_t start, end;

    while (j < 10) {
        start = clock();
        for (i = 0; i < TAM; i++) {
            cont++;
        }
        end = clock();
        tempo = (double)(end - start)/CLOCKS_PER_SEC;
        printf("Tempo 1: %.3f segundos.\n", tempo);
        total1+=tempo;
        ////////////////////////////////////////////
        i = 0;
        cont=0;
        start = clock();
        while (i < TAM) {
            cont++;
            i++;
        }
        end = clock();
        tempo = (double)(end - start)/CLOCKS_PER_SEC;
        printf("Tempo 2: %.3f segundos.\n", tempo);
        total2+=tempo;

        j++;
    }

    printf("%.3f segundos.\n%.3f segundos.\n", total1,total2);
    printf("%.3f segundos.\n", total1-total2);

    return 0;
}

Para calcular o tempo de execução em Python eu utilizei a biblioteca timeit (link para a documentação). Usei a função timeit() da biblioteca para avaliação do tempo de execução do código. Para isso precisei colocar os dois blocos de repetição dentro de funções para serem chamadas pela timeit().

Código em linguagem Python

import timeit

TAM = 100000000

def while_loop():
    i = 0
    cont = 0
    while i < TAM:
        cont += 1
        i += 1
    return cont


def for_loop():
    cont = 0
    for i in range(TAM):
        cont += 1
    return cont

print('while\t\t', timeit.timeit(while_loop, number=10))
print('for\t\t',   timeit.timeit(for_loop, number=10))

Sobre o desempenho das estruturas de repetição em Python, recomendo conferir o vídeo The Fastest Way to Loop in Python – An Unfortunate Truth. O vídeo mostrar outras avaliações de desempenho e foi de onde me inspirei para fazer essa minha explicação.

Para finalizar, segue um vídeo onde explico o processo, mostrando e comentando os resultados dos códigos.