Como usar operadores Python

Operadores Python ajudam você a trabalhar com valores e operandos. Eles também auxiliam a alterá-los e ligá-los uns aos outros. Operadores podem ser lógicos ou aritméticos.

O que são operadores Python e como eles funcionam?

Um operador é um caractere de uma operação. Operadores costumam ser usados para ligar diversos operandos, com a finalidade de formar um novo valor. A aplicação de um operador a um único operando faz com que este seja modificado.

O exemplo mais simples de operadores Python deve ser, provavelmente, o processo de somar dois números por meio da utilização de um operador de adição, representado pelo símbolo de mais, posicionado entre dois números. O Python avalia a expressão e retorna o valor correspondente:

1 + 1

O Python é especial, porque palavras curtas em inglês, como and (e), or (ou), is (é), not (não) e in (em), são usadas como operadores, além dos caracteres já conhecidos. A combinação de operadores e operandos resulta em uma expressão, como:

1 + 1 == 2

Quais são os operadores Python?

A linguagem Python compreende diversas classes de operadores. Eles operam com diferentes tipos de operandos e retornam um determinado tipo de resultado. A tabela abaixo dá um panorama dos diferentes tipos de operadores Python:

Operadores são classificados de acordo com sua aridade, juntamente com o tipo de operandos e o valor retornado. O termo diz respeito à quantidade de operandos que um operador combina. Na maioria dos casos, operadores binários, com dois operandos, são usados. Também há operadores unários, com apenas um operando, bem como operadores ternários, que conectam três operandos:

O que é precedência de operadores?

Entender o que é precedência de operadores é fundamental quando se aprende sobre operadores Python. O conceito vem da aritmética: PEMDAS, que indica a sequência correta de etapas a serem executadas em um cálculo. Recordemos: a expressão 3 8 + 2 deve ser interpretada como (3 8) + 2, e não como 3 (8 + 2). Assim como ocorre com os sinais de adição e de multiplicação, existem regras de precedência que regem todos os operadores Python. Observe, abaixo, um exemplo de expressão com os operadores lógicos and*,* or *e not:

if is_user and is_user_logged_in or is_admin and not login_blocked:
    ...

Sem conhecer as regras de precedência dos operadores Python, é impossível entender como os termos individuais devem se relacionar. A situação fica mais complicada quando múltiplos operadores são usados em uma só expressão. Em geral, o melhor a se fazer é não depender de uma compreensão perfeita das regras implícitas. Ao invés disso, explicite, com o uso de parênteses, como os termos de uma expressão devem se relacionar:

if (is_user and is_user_logged_in) or (is_admin and not login_blocked):
    ...

Os mesmos termos, agrupados de um jeito diferente, resultam em uma declaração também diferente:

if (is_user and is_user_logged_in or is_admin) and not login_blocked:
    ...

O que é sobrecarga de operadores, métodos Dunder e função operator em Python?

Alguns operadores Python são usados para mais de uma operação. Um bom exemplo é o sinal de soma (mais): ele funciona tanto como operador de adição para números, quanto como operador de concatenação para sequências de strings e listas. Podemos somar dois números com o operador de adição:

8 + 3 == 11

Também podemos concatenar duas strings usando o mesmo operador:

"Walter" + "White" == "WalterWhite"

Ainda é possível concatenar listas com esse operador:

['Jack', 'Jim'] + ['John'] == ['Jack', 'Jim', 'John']

A multifuncionalidade do sinal de soma como operador reflete um conceito comum na ciência da computação: sobrecarga de operadores. Você já deve ter ouvido falar nesta expressão, que se refere a um único operador que desempenha operações diferentes, dependendo do tipo de dado do operando.

Em Python, sobrecarga de operadores se dá desta forma: um operador e seus operandos são interpretados como referências à função correspondente. O método Dunder do primeiro operando é habilitado e recebe os outros operandos como argumentos. “Dunder” abrevia o termo double underscore (sublinhado duplo, em português). Assim sendo, o operador de soma corresponde ao método Dunder __add__(). Objetos que implementam um método __add__() podem ser conectados usando o operador de soma. O que exatamente constitui a ligação depende do objeto em questão.

Além dos métodos Dunder, o módulo operator contém funções que incluem funcionalidades de operadores Python. Por exemplo, operator.add(a, b) habilita o método Dunder a.__add__(b), que é equivalente à expressão a + b. Na medida do possível, listaremos a função operator de cada operação apresentada por este artigo. O nome da função operator corresponde ao nome do respectivo método Dunder. Você pode usar a tabela abaixo como referência para implementar sua própria funcionalidade:

Operadores usam a notação infixa, que insere o operador entre os operandos. Já funções usam a notação prefixa. Ambas as notações são equivalentes:

Acompanhe o exemplo abaixo. Nele, definimos dois números e os adicionamos ao operador, à função operator e ao método Dunder correspondente:

import operator
a = 42
b = 69
assert a + b == operator.add(a, b) == a.__add__(b)

Expressões mais complexas também podem ser escritas com funções operator. A combinação dos operadores Python de soma e de igualdade em uma notação prefixa funciona da seguinte maneira:

import operator
assert 'Py' + 'thon' == 'Python' 
 
assert operator.eq(operator.add('Py', 'thon'), 'Python')

Panorama de operadores Python

Conheça, agora, os 11 tipos diferentes de operadores Python.

Operadores aritméticos

Operadores Python aritméticos atuam com números, para criar um novo número. Todos constituem operadores binários, com exceção dos símbolos de “mais” e de “menos”, que são unários, como mostra a tabela:

O operador módulo é usado por padrão para determinar se um número é par, já que um número par dividido por dois tem resto zero. Observe uma função Python com o operador módulo:

def is_even(number):
    return number % 2 == 0
assert is_even(8) and not is_even(7)

Multiplicações de matriz requerem o uso de um pacote, como NumPy.

Operadores de comparação

Operadores Python de comparação indicam como dois elementos podem ser ordenados entre eles. O valor resultante é booleano e costuma ser usado para organizar algoritmos:

Operadores lógicos

Os operadores Python lógicos and e or ligam múltiplos operandos, seguindo a lógica booleana. Como resultado, os dois operadores retornam o último objeto avaliado. O operador lógico not interpreta um objeto em um contexto booleano e nega seu valor verdadeiro:

Visualizar o efeito das operações lógicas em uma tabela pode ajudar na compreensão. Analise, abaixo, a lógica AND:

e a lógica OR:

Operandos de operadores Python booleanos não se limitam a variáveis booleanas. Isso quer dizer que qualquer objeto de Python pode ser interpretado em um contexto booleano. Os objetos a seguir são avaliados como falsos no contexto booleano e, portanto, chamados de falsy:

Operadores bitwise

Operadores Python bitwise operam com inteiros, que são interpretados como sequências de bits. Todos são operadores binários, com exceção do operador bitwise NOT:

Operadores bitwise são adequados para operações matemáticas otimizadas. O deslocamento para a esquerda corresponde a uma multiplicação por uma potência de dois:

Criamos uma tabela de bits individuais para ilustrarmos as operações bitwise AND, OR e NOT. Elas são aplicadas a um número em representação binária, usando uma máscara de bits:

O operador bitwise NOT inverte a sequência de bits. Ele transforma todo 1 em 0 e vice-versa. Além disso, o sinal do número também é invertido:

Operadores de atribuição

Em grande parte das linguagens de programação, atribuições são declarações básicas. Operadores Python de atribuição atribuem um valor ao nome de uma variável. Existe, ainda, o novo operador walrus, que permite criar uma atribuição dentro de uma expressão. Também há diversas declarações de atribuição estendidas, que combinam uma atribuição com outra operação:

A linguagem Python reconhece operadores de atribuição estendidos para operações bitwise e aritméticas. Não os listaremos individualmente aqui. Exibiremos apenas o padrão geral, usando a atribuição estendida de concatenação como exemplo. Primeiramente, mostramos um código que anexa uma nova parte a uma string existente:

name = 'Walter'
name = name + 'White'
assert name == 'WalterWhite'

Um exemplo equivalente usando o operador estendido de concatenação += produz o mesmo resultado, mas seu código é mais conciso e expressivo:

name = 'Walter'
name += 'White'
assert name == 'WalterWhite'

Operadores de identidade

O operador Python is testa se duas variáveis se referem ao mesmo objeto armazenado. A identidade do objeto contrasta com a igualdade do objeto, que é testada pelo operador de comparação ==. Em Python, is corresponde ao operador de igualdade estrita ===, do JavaScript. Phyton também tem um teste de identidade negada, usando o operador is not:

Acompanhe nossos exemplos abaixo. Criamos uma referência para um objeto armazenado. Depois, criamos outra referência com um alias. O operador retorna como verdadeiro quando as duas variáveis apontam para o mesmo objeto armazenado:

# assign value to name 
a = [42] 
# reference existing object 
b = a 
# if this holds 
assert a is b 
# so will this 
assert a == b

No exemplo a seguir, criamos duas referências na memória para objetos independentes. Embora os objetos sejam os mesmos, suas identidades são distintas. Por isso, o operador retorna como falso:

# assign the same value to different names 
a = [42]
b = [42]
# `a`, `b` are two different objects 
assert a is not b 
# that contain the same value 
assert a == b

Operador condicional

O operador Python condicional pode ser usado no lugar dos termos if-else. Ele é bastante utilizado para diferenciar dois valores possíveis em atribuições e é conhecido como um operador ternário, já que combina uma condição e duas expressões.

Primeiramente, observe um exemplo usando a declaração if-else no Python. O código a seguir define Celsius ou Fahrenheit como unidade de medida de temperatura, a depender do sistema escolhido:

if system == 'metric':
    unit = 'C' 
else: 
    unit = 'F

O código pode ser simplificado a uma única atribuição, por meio de um operador condicional:

unit = 'C' if system == 'metric' else 'F'.

Operadores de conjunto

Além de strings, tuplas, listas e dicionários, o Python oferece suporte padrão a conjuntos como um tipo composto de dados. A sobrecarga de operadores é definida para as operações usuais com conjuntos:

Operadores de associação

Os operadores Python de associação in e not in indicam se um objeto está incluído em uma coleção.

Operadores de associação trabalham com iteráveis e realizam uma verificação de igualdade para determinar se o objeto em foco está presente na coleção:

'Py' in 'Python'
'Px' not in 'Python'
'Jack' in ['Jim', 'Jack']

A utilização do operador in facilita a escrita de códigos da seguinte forma:

def my_in(target, collection):
    for element in collection:
        if element == target:
            return true
    return False
# test
word = 'Python'
letter = 'y'
assert (my_in(letter, word)) == (letter in word)

Operador de concatenação

Operadores Python de concatenação são usados para concatenar sequências do mesmo tipo. O símbolo do operador é o sinal de mais.

Observe os exemplos a seguir. No primeiro, concatenamos duas strings, duas listas e duas tuplas:

assert "Walter" + "White" == 'WalterWhite'
assert ['a', 'b'] + ['c'] == ['a', 'b', 'c']
assert ('q', 'r') + ('s', 't') == ('q', 'r', 's', 't')

Python é usado como linguagem de programação web. Assim sendo, operadores de concatenação podem ser usados, por exemplo, para criar tags HTML:

site_title = 'Bem-vindo'
print('<h1>' + site_title + '</h1>')

Operadores de concatenação são diferentes em Python e PHP. O PHP usa o ponto final (“.”) como símbolo. Segue, abaixo, exemplo em PHP:

$siteTitle = 'Bem-vindo';
echo '<h1>' . $siteTitle . '</h1>';

Operadores de indexação e fatiamento

O operador Python de indexação é usado para extrair um elemento específico de uma coleção, ao passo que o operador de fatiamento é usado para extrair uma subsequência.

Operadores Python de indexação e fatiamento recorrem ao método Dunder __getitem__(), por meio de um index numérico ou de uma fatia (slice) do objeto:

names = ['Jim', 'Jack', 'John']
names[0] == names.\_\_getitem\_\_(0)
names[0:2] == names.\_\_getitem\_\_(slice(0, 2))

O operador de fatiamento é prático, pois permite extrair uma subsequência sem que seja necessário o uso de um Python loop for ou de um Python loop while. Isso permite que programadores escrevam um código mais conciso. Observe:

word = 'Python'
start, stop, step = 0, 5, 2
index, substring = start, ''
while index in range(start, stop, step):
    substring += word[index]
    index += step
# test
assert substring == word[start:stop:step]