Como usar ope­ra­do­res Python

Ope­ra­do­res Python ajudam você a trabalhar com valores e operandos. Eles também auxiliam a alterá-los e ligá-los uns aos outros. Ope­ra­do­res podem ser lógicos ou arit­mé­ti­cos.

O que são ope­ra­do­res Python e como eles funcionam?

Um operador é um caractere de uma operação. Ope­ra­do­res costumam ser usados para ligar diversos operandos, com a fi­na­li­dade de formar um novo valor. A aplicação de um operador a um único operando faz com que este seja mo­di­fi­cado.

O exemplo mais simples de ope­ra­do­res Python deve ser, pro­va­vel­mente, o processo de somar dois números por meio da uti­li­za­ção de um operador de adição, re­pre­sen­tado pelo símbolo de mais, po­si­ci­o­nado entre dois números. O Python avalia a expressão e retorna o valor cor­res­pon­dente:

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 ope­ra­do­res, além dos ca­rac­te­res já co­nhe­ci­dos. A com­bi­na­ção de ope­ra­do­res e operandos resulta em uma expressão, como:

1 + 1 == 2

Quais são os ope­ra­do­res Python?

A linguagem Python com­pre­ende diversas classes de ope­ra­do­res. Eles operam com di­fe­ren­tes tipos de operandos e retornam um de­ter­mi­nado tipo de resultado. A tabela abaixo dá um panorama dos di­fe­ren­tes tipos de ope­ra­do­res Python:

Ope­ra­do­res são clas­si­fi­ca­dos de acordo com sua aridade, jun­ta­mente com o tipo de operandos e o valor retornado. O termo diz respeito à quan­ti­dade de operandos que um operador combina. Na maioria dos casos, ope­ra­do­res binários, com dois operandos, são usados. Também há ope­ra­do­res unários, com apenas um operando, bem como ope­ra­do­res ternários, que conectam três operandos:

O que é pre­ce­dên­cia de ope­ra­do­res?

Entender o que é pre­ce­dên­cia de ope­ra­do­res é fun­da­men­tal quando se aprende sobre ope­ra­do­res Python. O conceito vem da arit­mé­tica: PEMDAS, que indica a sequência correta de etapas a serem exe­cu­ta­das em um cálculo. Re­cor­de­mos: a expressão 3 8 + 2 deve ser in­ter­pre­tada como (3 8) + 2, e não como 3 (8 + 2). Assim como ocorre com os sinais de adição e de mul­ti­pli­ca­ção, existem regras de pre­ce­dên­cia que regem todos os ope­ra­do­res Python. Observe, abaixo, um exemplo de expressão com os ope­ra­do­res 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 pre­ce­dên­cia dos ope­ra­do­res Python, é im­pos­sí­vel entender como os termos in­di­vi­du­ais devem se re­la­ci­o­nar. A situação fica mais com­pli­cada quando múltiplos ope­ra­do­res são usados em uma só expressão. Em geral, o melhor a se fazer é não depender de uma com­pre­en­são perfeita das regras im­plí­ci­tas. Ao invés disso, explicite, com o uso de pa­rên­te­ses, como os termos de uma expressão devem se re­la­ci­o­nar:

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 de­cla­ra­ção também diferente:

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

O que é so­bre­carga de ope­ra­do­res, métodos Dunder e função operator em Python?

Alguns ope­ra­do­res 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 con­ca­te­na­ção para sequên­cias de strings e listas. Podemos somar dois números com o operador de adição:

8 + 3 == 11

Também podemos con­ca­te­nar duas strings usando o mesmo operador:

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

Ainda é possível con­ca­te­nar listas com esse operador:

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

A mul­ti­fun­ci­o­na­li­dade do sinal de soma como operador reflete um conceito comum na ciência da com­pu­ta­ção: so­bre­carga de ope­ra­do­res. Você já deve ter ouvido falar nesta expressão, que se refere a um único operador que de­sem­pe­nha operações di­fe­ren­tes, de­pen­dendo do tipo de dado do operando.

Em Python, so­bre­carga de ope­ra­do­res se dá desta forma: um operador e seus operandos são in­ter­pre­ta­dos como re­fe­rên­cias à função cor­res­pon­dente. O método Dunder do primeiro operando é ha­bi­li­tado e recebe os outros operandos como ar­gu­men­tos. “Dunder” abrevia o termo double un­ders­core (su­bli­nhado duplo, em português). Assim sendo, o operador de soma cor­res­ponde ao método Dunder __add__(). Objetos que im­ple­men­tam um método __add__() podem ser co­nec­ta­dos usando o operador de soma. O que exa­ta­mente 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 fun­ci­o­na­li­da­des de ope­ra­do­res Python. Por exemplo, operator.add(a, b) habilita o método Dunder a.__add__(b), que é equi­va­lente à expressão a + b. Na medida do possível, lis­ta­re­mos a função operator de cada operação apre­sen­tada por este artigo. O nome da função operator cor­res­ponde ao nome do res­pec­tivo método Dunder. Você pode usar a tabela abaixo como re­fe­rên­cia para im­ple­men­tar sua própria fun­ci­o­na­li­dade:

Ope­ra­do­res 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 equi­va­len­tes:

Acompanhe o exemplo abaixo. Nele, definimos dois números e os adi­ci­o­na­mos ao operador, à função operator e ao método Dunder cor­res­pon­dente:

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

Ex­pres­sões mais complexas também podem ser escritas com funções operator. A com­bi­na­ção dos ope­ra­do­res 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 ope­ra­do­res Python

Conheça, agora, os 11 tipos di­fe­ren­tes de ope­ra­do­res Python.

Ope­ra­do­res arit­mé­ti­cos

Ope­ra­do­res Python arit­mé­ti­cos atuam com números, para criar um novo número. Todos cons­ti­tuem ope­ra­do­res 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 de­ter­mi­nar 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
# test
assert is_even(8) and not is_even(7)

Mul­ti­pli­ca­ções de matriz requerem o uso de um pacote, como NumPy.

Ope­ra­do­res de com­pa­ra­ção

Ope­ra­do­res Python de com­pa­ra­ção indicam como dois elementos podem ser ordenados entre eles. O valor re­sul­tante é booleano e costuma ser usado para organizar al­go­rit­mos:

Ope­ra­do­res lógicos

Os ope­ra­do­res Python lógicos and e or ligam múltiplos operandos, seguindo a lógica booleana. Como resultado, os dois ope­ra­do­res retornam o último objeto avaliado. O operador lógico not in­ter­preta um objeto em um contexto booleano e nega seu valor ver­da­deiro:

Vi­su­a­li­zar o efeito das operações lógicas em uma tabela pode ajudar na com­pre­en­são. Analise, abaixo, a lógica AND:

e a lógica OR:

Operandos de ope­ra­do­res Python booleanos não se limitam a variáveis booleanas. Isso quer dizer que qualquer objeto de Python pode ser in­ter­pre­tado em um contexto booleano. Os objetos a seguir são avaliados como falsos no contexto booleano e, portanto, chamados de falsy:

Ope­ra­do­res bitwise

Ope­ra­do­res Python bitwise operam com inteiros, que são in­ter­pre­ta­dos como sequên­cias de bits. Todos são ope­ra­do­res binários, com exceção do operador bitwise NOT:

Ope­ra­do­res bitwise são adequados para operações ma­te­má­ti­cas oti­mi­za­das. O des­lo­ca­mento para a esquerda cor­res­ponde a uma mul­ti­pli­ca­ção por uma potência de dois:

Criamos uma tabela de bits in­di­vi­du­ais para ilus­trar­mos as operações bitwise AND, OR e NOT. Elas são aplicadas a um número em re­pre­sen­ta­ção binária, usando uma máscara de bits:

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

Ope­ra­do­res de atri­bui­ção

Em grande parte das lin­gua­gens de pro­gra­ma­ção, atri­bui­ções são de­cla­ra­ções básicas. Ope­ra­do­res Python de atri­bui­ção atribuem um valor ao nome de uma variável. Existe, ainda, o novo operador walrus, que permite criar uma atri­bui­ção dentro de uma expressão. Também há diversas de­cla­ra­ções de atri­bui­ção es­ten­di­das, que combinam uma atri­bui­ção com outra operação:

A linguagem Python reconhece ope­ra­do­res de atri­bui­ção es­ten­di­dos para operações bitwise e arit­mé­ti­cas. Não os lis­ta­re­mos in­di­vi­du­al­mente aqui. Exi­bi­re­mos apenas o padrão geral, usando a atri­bui­ção estendida de con­ca­te­na­ção como exemplo. Pri­mei­ra­mente, mostramos um código que anexa uma nova parte a uma string existente:

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

Um exemplo equi­va­lente usando o operador estendido de con­ca­te­na­ção += produz o mesmo resultado, mas seu código é mais conciso e ex­pres­sivo:

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

Ope­ra­do­res de iden­ti­dade

O operador Python is testa se duas variáveis se referem ao mesmo objeto ar­ma­ze­nado. A iden­ti­dade do objeto contrasta com a igualdade do objeto, que é testada pelo operador de com­pa­ra­ção ==. Em Python, is cor­res­ponde ao operador de igualdade estrita ===, do Ja­vaS­cript. Phyton também tem um teste de iden­ti­dade negada, usando o operador is not:

Acompanhe nossos exemplos abaixo. Criamos uma re­fe­rên­cia para um objeto ar­ma­ze­nado. Depois, criamos outra re­fe­rên­cia com um alias. O operador retorna como ver­da­deiro quando as duas variáveis apontam para o mesmo objeto ar­ma­ze­nado:

# 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 re­fe­rên­cias na memória para objetos in­de­pen­den­tes. Embora os objetos sejam os mesmos, suas iden­ti­da­des 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 con­di­ci­o­nal

O operador Python con­di­ci­o­nal pode ser usado no lugar dos termos if-else. Ele é bastante utilizado para di­fe­ren­ciar dois valores possíveis em atri­bui­ções e é conhecido como um operador ternário, já que combina uma condição e duas ex­pres­sões.

Pri­mei­ra­mente, observe um exemplo usando a de­cla­ra­ção if-else no Python. O código a seguir define Celsius ou Fah­re­nheit como unidade de medida de tem­pe­ra­tura, a depender do sistema escolhido:

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

O código pode ser sim­pli­fi­cado a uma única atri­bui­ção, por meio de um operador con­di­ci­o­nal:

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

Ope­ra­do­res de conjunto

Além de strings, tuplas, listas e di­ci­o­ná­rios, o Python oferece suporte padrão a conjuntos como um tipo composto de dados. A so­bre­carga de ope­ra­do­res é definida para as operações usuais com conjuntos:

Ope­ra­do­res de as­so­ci­a­ção

Os ope­ra­do­res Python de as­so­ci­a­ção in e not in indicam se um objeto está incluído em uma coleção.

Ope­ra­do­res de as­so­ci­a­ção trabalham com iteráveis e realizam uma ve­ri­fi­ca­ção de igualdade para de­ter­mi­nar se o objeto em foco está presente na coleção:

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

A uti­li­za­çã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 con­ca­te­na­ção

Ope­ra­do­res Python de con­ca­te­na­ção são usados para con­ca­te­nar sequên­cias do mesmo tipo. O símbolo do operador é o sinal de mais.

Observe os exemplos a seguir. No primeiro, con­ca­te­na­mos 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 pro­gra­ma­ção web. Assim sendo, ope­ra­do­res de con­ca­te­na­ção podem ser usados, por exemplo, para criar tags HTML:

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

Ope­ra­do­res de con­ca­te­na­ção são di­fe­ren­tes 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>';

Ope­ra­do­res de indexação e fa­ti­a­mento

O operador Python de indexação é usado para extrair um elemento es­pe­cí­fico de uma coleção, ao passo que o operador de fa­ti­a­mento é usado para extrair uma sub­sequên­cia.

Ope­ra­do­res Python de indexação e fa­ti­a­mento 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 fa­ti­a­mento é prático, pois permite extrair uma sub­sequên­cia sem que seja ne­ces­sá­rio o uso de um Python loop for ou de um Python loop while. Isso permite que pro­gra­ma­do­res 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]