Operadores no Python

Este artigo explica os operadores no Python.

YouTube Video

Operadores no Python

O Python tem vários operadores, que podem ser amplamente categorizados da seguinte forma. Explicaremos operadores representativos para cada categoria.

Operadores Aritméticos

Os operadores aritméticos são operadores usados para realizar cálculos com números.

 1a = 10
 2b = 3
 3
 4print(f"{a} + {b} = {a + b}")     # Addition
 5print(f"{a} - {b} = {a - b}")     # Subtraction
 6print(f"{a} * {b} = {a * b}")     # Multiplication
 7print(f"{a} / {b} = {a / b}")     # Division (float)
 8print(f"6 / 3 = {6 / 3}")         # Division (float)
 9print(f"{a} // {b} = {a // b}")   # Floor Division
10print(f"{a} % {b} = {a % b}")     # Modulo (remainder)
11print(f"{a} ** {b} = {a ** b}")   # Exponentiation

• Além das quatro operações aritméticas básicas, o Python fornece operadores para divisão (/), divisão inteira (//), módulo (%) e exponenciação (**). A divisão retorna um número de ponto flutuante mesmo ao dividir inteiros.

Operadores de Atribuição

Operadores de atribuição são usados para atribuir valores às variáveis.

 1x = 5           # x = 5
 2
 3x += 3          # x = x + 3
 4x -= 2          # x = x - 2
 5x *= 4          # x = x * 4
 6x /= 3          # x = x / 3
 7x //= 2         # x = x // 2
 8x %= 5          # x = x % 5
 9x **= 3         # x = x ** 3
10
11x = 0b1100      # x = 0b1100 (12)
12
13x &= 0b1010     # x = x & 0b1010
14x |= 0b0011     # x = x | 0b0011
15x ^= 0b0101     # x = x ^ 0b0101
16x <<= 2         # x = x << 2
17x >>= 1         # x = x >> 1
18
19print(bin(x))   # Display in binary
20print(x)        # Display in decimal
21
22# Walrus operator
23if (n := len("hello")) > 3:
24    print(f"Length is {n}")

• Os operadores de atribuição permitem combinar a atribuição padrão com vários operadores para atribuir o resultado.
• O operador walrus (:=) é uma expressão de atribuição disponível no Python 3.8 e posterior.
• Enquanto a atribuição padrão só pode ser usada como uma instrução, o operador walrus permite atribuição dentro de uma expressão.

Operadores de Comparação

Os operadores de comparação comparam valores e retornam True ou False.

 1a = 10
 2b = 20
 3
 4# Equal to (==)
 5print(f"{a} == {b} -> {a == b}")      # False: a and b are not equal
 6print(f"3 == 3.0 -> {3 == 3.0}")      # True: int and float with the same value are equal
 7print(f"3 == '3' -> {3 == '3'}")      # False: different types (int vs str)
 8print(f"True == 1 -> {True == 1}")    # True: True is equivalent to 1
 9print(f"False == 0 -> {False == 0}")  # True: False is equivalent to 0
10print(f"None == 0 -> {None == 0}")    # False: None is not equal to 0
11
12# Not equal to (!=)
13print(f"{a} != {b} -> {a != b}")      # True: a and b are not equal
14
15# Greater than (>)
16print(f"{b} > {a} -> {b > a}")        # True: 20 > 10
17
18# Less than (<)
19print(f"{a} < {b} -> {a < b}")        # True: 10 < 20
20
21# Greater than or equal to (>=)
22print(f"{a} >= 10 -> {a >= 10}")      # True: a is greater than or equal to 10
23
24# Less than or equal to (<=)
25print(f"{a} <= 10 -> {a <= 10}")      # True: a is less than or equal to 10

• Os operadores de comparação comparam dois valores por ordem ou igualdade e retornam True ou False como resultado.
• Em Python, você deve ter cuidado ao comparar diferentes tipos de dados. Alguns tipos podem ser comparados entre si, mas os resultados podem não ser intuitivos.

Operadores Lógicos

Os operadores lógicos são usados para combinar expressões lógicas.

1x = 10
2print(x > 5 and x < 20)  # True
3print(x < 5 or x > 20)   # False
4print(not x == 10)       # False

• and é um operador lógico que retorna True apenas se ambas as condições à esquerda e à direita forem True.
• or é um operador lógico que retorna True se uma das condições à esquerda ou à direita for True.
• not é um operador lógico que inverte o valor de verdade de uma condição. Se for True, torna-se False, e se for False, torna-se True.

Precedência dos operadores lógicos

Os operadores têm precedência. Essa é a regra que determina qual operador é avaliado primeiro em uma expressão. Os operadores lógicos são avaliados na ordem: not, depois and e, por fim, or.

1result = True or False and False
2print(result)  # True
3
4result = (True or False) and False
5print(result)  # False

たとえば、

No primeiro exemplo, and é avaliado primeiro, então False and False se torna False e, como resultado, True or False se torna True. Você também pode alterar a ordem de avaliação usando parênteses, como mostrado no segundo exemplo.

Operadores de Manipulação de Bits

Os operadores bit-a-bit realizam operações no nível dos bits.

 1# Sample code for bitwise operators
 2
 3# Define two integers
 4a = 5  # Binary: 0101
 5b = 3  # Binary: 0011
 6
 7# Bitwise AND
 8result_and = a & b  # Binary: 0001 -> Decimal: 1
 9print(f"{a} & {b} = {result_and}")
10
11# Bitwise OR
12result_or = a | b  # Binary: 0111 -> Decimal: 7
13print(f"{a} | {b} = {result_or}")
14
15# Bitwise XOR
16result_xor = a ^ b  # Binary: 0110 -> Decimal: 6
17print(f"{a} ^ {b} = {result_xor}")
18
19# Bitwise NOT (inverting bits)
20result_not = ~a  # Binary: -(0101 + 1) -> Decimal: -6
21print(f"~{a} = {result_not}")
22
23# Left shift
24shift_left = a << 1  # Binary: 1010 -> Decimal: 10
25print(f"{a} << 1 = {shift_left}")
26
27# Right shift
28shift_right = a >> 1  # Binary: 0010 -> Decimal: 2
29print(f"{a} >> 1 = {shift_right}")

• Você pode realizar operações bit a bit AND, OR, XOR, NOT, assim como operações de deslocamento de bits. Você também pode combiná-los com operadores de atribuição como &=.

Operadores de Pertinência

Os operadores de associação são usados com coleções como listas e dicionários.

 1x = [1, 2, 3]
 2y = 2
 3z = 4
 4
 5print("y in x : ", y in x)  # Result is True
 6print("z in x : ", z in x)  # Result is False
 7
 8print("y not in x : ", y not in x)  # Result is False
 9print("z not in x : ", z not in x)  # Result is True
10
11text = "hello world"
12print("'world' in 'hello world' : ",      "world" in text)      # True
13print("'python' not in 'hello world' : ", "python" not in text) # True

• O operador in é usado para determinar se um valor específico está contido em uma sequência, como uma lista ou string, ou em uma coleção, como um dicionário.
• O operador not in é usado para determinar se um valor específico não está contido em uma sequência ou coleção.

Operadores de Identidade

Os operadores de identidade verificam a identidade dos objetos.

 1x = [1, 2, 3]
 2y = x
 3z = x.copy()
 4
 5print("x is y : ", x is y)  # Result is True
 6print("x is z : ", x is z)  # Result is False
 7
 8print("x is not y : ", x is not y)  # Result is False
 9print("x is not z : ", x is not z)  # Result is True
10
11print("x == y : ", x == y)  # Result is True
12print("x == z : ", x == z)  # Result is True

• O operador is verifica se dois objetos são o mesmo objeto (ou seja, referenciam o mesmo local na memória).
• O operador is not verifica se dois objetos são objetos diferentes.
• Por exemplo, x is y difere de x == y pois verifica a identidade do objeto, não a igualdade de valor.

Verificação de Tipo

Em Python, você usa a função isinstance() para verificar se um valor é de um tipo específico. Você também pode usar a função type() para verificar o tipo exato de uma variável. Embora não sejam operadores, são mecanismos básicos de verificação de tipo.

 1x = 10
 2print(isinstance(x, int))  # True
 3
 4y = "hello"
 5print(isinstance(y, str))  # True
 6
 7z = [1, 2, 3]
 8print(isinstance(z, list))  # True
 9
10print(type(10))        # <class 'int'>
11print(type("hello"))   # <class 'str'>
12
13print("isinstance(3, int) : ", isinstance(3, int))  # True
14print("type(3) is int : ", type(3) is int)          # True
15print("type(True) is bool : ", type(True) is bool)  # True

• isinstance() é uma função que verifica se um objeto é uma instância de uma classe especificada ou de sua subclasse.
• type() é uma função que retorna o tipo exato (classe) de um objeto. Ela geralmente é usada quando se deseja realizar uma comparação estrita de tipo.
• isinstance() considera relacionamentos de herança, enquanto type() verifica apenas correspondências exatas.

Resumo

Ao usar cada operador, você precisa escolher adequadamente com base no propósito e no tipo. Como Python é uma linguagem de tipagem dinâmica, o resultado de uma operação pode variar dependendo do tipo dos valores calculados.

Você pode acompanhar o artigo acima usando o Visual Studio Code em nosso canal do YouTube. Por favor, confira também o canal do YouTube.

YouTube Video