Precedência de Operadores em Python

Introdução

Neste laboratório, você obterá uma compreensão prática da precedência de operadores em Python. Assim como na matemática, o Python segue regras específicas para determinar a ordem em que as operações são executadas dentro de uma expressão. Um domínio sólido dessas regras é essencial para escrever um código que seja correto e previsível.

Começaremos explorando a precedência dos operadores aritméticos básicos. Em seguida, veremos como operadores de nível superior, como exponenciação e comparação, se encaixam na hierarquia. Finalmente, você aprenderá a usar parênteses para anular a ordem de operações padrão, uma técnica crucial tanto para controlar cálculos quanto para melhorar a legibilidade do código.

Precedência Aritmética Básica

Em Python, assim como na matemática padrão, alguns operadores aritméticos têm maior precedência do que outros. Especificamente, a multiplicação (*) e a divisão (/) são executadas antes da adição (+) e da subtração (-). Quando os operadores têm a mesma precedência, eles são avaliados da esquerda para a direita.

Vamos observar esse comportamento. O processo de configuração já criou um arquivo para você. No explorador de arquivos do WebIDE à esquerda, localize e abra o arquivo chamado operator_precedence.py localizado no diretório ~/project.

Adicione o seguinte código ao arquivo:

## Multiplication and division are evaluated before addition and subtraction.
result = 10 + 4 * 3 - 10 / 5
print(result)

Esta expressão contém adição, multiplicação, subtração e divisão. Vamos prever a ordem das operações:

1. O Python primeiro executará a multiplicação: 4 * 3 é igual a 12.
2. Em seguida, executará a divisão: 10 / 5 é igual a 2.0. Note que a divisão padrão no Python 3 sempre resulta em um número de ponto flutuante (float).
3. A expressão agora é 10 + 12 - 2.0.
4. Finalmente, executará a adição e a subtração da esquerda para a direita: 10 + 12 é 22, e 22 - 2.0 é 20.0.

Salve o arquivo pressionando Ctrl + S. Para executar o código, abra um terminal no WebIDE (Terminal -> New Terminal) e execute o seguinte comando:

python ~/project/operator_precedence.py

Você verá o resultado calculado impresso no terminal.

20.0

A saída corresponde à nossa previsão, confirmando a precedência da multiplicação e da divisão sobre a adição e a subtração.

Operadores de Nível Superior

A hierarquia de operadores do Python estende-se além da aritmética básica. O operador de exponenciação (**) tem uma precedência maior do que a multiplicação e a divisão. Além disso, todos os operadores aritméticos têm uma precedência maior do que os operadores de comparação, como "maior que" (>).

Vamos adicionar mais exemplos ao nosso script para ver isso em ação. Modifique o arquivo ~/project/operator_precedence.py para incluir duas novas expressões:

## Multiplication and division are evaluated before addition and subtraction.
result = 10 + 4 * 3 - 10 / 5
print(result)

## Exponentiation has higher precedence than multiplication.
exp_result = 2 * 3 ** 2
print(exp_result)

## Arithmetic operators have higher precedence than comparison operators.
comp_result = 18 > 5 + 10
print(comp_result)

Vamos analisar as novas linhas:

1. Em 2 * 3 ** 2, a exponenciação 3 ** 2 é calculada primeiro, resultando em 9. Em seguida, a multiplicação 2 * 9 é realizada, resultando em 18.
2. Em 18 > 5 + 10, a adição 5 + 10 é calculada primeiro, resultando em 15. Em seguida, a comparação 18 > 15 é avaliada, o que é True.

Salve o arquivo (Ctrl + S) e execute o script novamente.

python ~/project/operator_precedence.py

O terminal exibirá agora os resultados das três expressões.

20.0
18
True

Isso confirma que o Python avalia a exponenciação primeiro, seguida por outras operações aritméticas e, por fim, as operações de comparação.

Usando Parênteses para Controlar a Ordem de Avaliação

Embora as regras de precedência do Python sejam consistentes, expressões complexas podem ser difíceis de ler. Para anular a ordem padrão ou simplesmente deixar suas intenções claras, você pode usar parênteses (). Qualquer expressão contida em parênteses é avaliada primeiro.

Vamos modificar um de nossos exemplos anteriores para ver o efeito dos parênteses. Adicione uma nova expressão ao final de ~/project/operator_precedence.py.

## Multiplication and division are evaluated before addition and subtraction.
result = 10 + 4 * 3 - 10 / 5
print(result)

## Exponentiation has higher precedence than multiplication.
exp_result = 2 * 3 ** 2
print(exp_result)

## Arithmetic operators have higher precedence than comparison operators.
comp_result = 18 > 5 + 10
print(comp_result)

## Using parentheses to change the order of evaluation.
forced_result = (10 + 4) * 3
print(forced_result)

Vamos analisar a nova linha (10 + 4) * 3:

1. Como 10 + 4 está dentro de parênteses, é avaliado primeiro, resultando em 14.
2. Em seguida, a multiplicação 14 * 3 é realizada, resultando em 42.

Isso é diferente de 10 + 4 * 3, que sabemos que resulta em 22. Os parênteses mudaram completamente o resultado.

Salve o arquivo e execute o script pela última vez.

python ~/project/operator_precedence.py

A saída agora incluirá o resultado da nossa expressão entre parênteses.

20.0
18
True
42

Usar parênteses, mesmo quando não são estritamente necessários, é uma boa prática. Isso torna a ordem das operações explícita, o que melhora a legibilidade do código e reduz a chance de bugs causados por mal-entendidos de precedência.

Resumo

Neste laboratório, você explorou o conceito fundamental de precedência de operadores em Python. Você começou com a aritmética básica, confirmando que a multiplicação e a divisão têm prioridade sobre a adição e a subtração. Em seguida, aprendeu que outros operadores, como exponenciação e comparação, têm seu próprio lugar na hierarquia.

Mais importante ainda, você praticou o uso de parênteses para controlar explicitamente a ordem de avaliação. Essa habilidade é vital para escrever código que não seja apenas funcionalmente correto, mas também claro e fácil de ser entendido por outros. Ao dominar a precedência de operadores, você deu um passo significativo para escrever programas Python mais robustos e confiáveis.