Introdução
Neste laboratório, você obterá uma compreensão abrangente de vários operadores em Python, um conceito fundamental para escrever código eficaz. Exploraremos e praticaremos o uso de operadores aritméticos, de comparação, de atribuição, lógicos, bitwise (de bits), de associação (membership) e de identidade.
Através de exercícios práticos utilizando o editor VS Code integrado e o terminal, você aprenderá a realizar cálculos, fazer comparações, atribuir valores, combinar condições, manipular bits, verificar a associação (membership) e comparar identidades de objetos. Ao final deste laboratório, você estará proficiente no uso desses operadores para construir programas Python mais complexos e funcionais.
Explore Operadores Aritméticos e de Comparação
Nesta etapa, exploraremos os operadores aritméticos e de comparação fundamentais em Python. Estes operadores são essenciais para realizar cálculos e tomar decisões em seus programas. O ambiente de laboratório já criou um arquivo chamado operators.py para você no diretório ~/project.
Primeiro, localize o arquivo operators.py no explorador de arquivos no lado esquerdo do editor VS Code e abra-o. Escreveremos todo o nosso código neste único arquivo.
Vamos começar com os operadores aritméticos. Adicione o seguinte código Python ao arquivo operators.py:
## Arithmetic Operators
a = 21
b = 5
print(f'{a} + {b} = {a + b}')
print(f'{a} - {b} = {a - b}')
print(f'{a} * {b} = {a * b}')
print(f'{a} / {b} = {a / b}') ## Standard division
print(f'{a} // {b} = {a // b}') ## Floor division, rounds down to the nearest whole number
print(f'{a} % {b} = {a % b}') ## Modulo, returns the remainder
print(f'{a} ** {b} = {a ** b}') ## Exponentiation, a to the power of b
Após adicionar o código, salve o arquivo pressionando Ctrl + S.
Para executar o script, abra o terminal integrado no VS Code selecionando Terminal > New Terminal no menu superior. Em seguida, execute o seguinte comando:
python ~/project/operators.py
Você deverá ver a seguinte saída no terminal:
21 + 5 = 26
21 - 5 = 16
21 * 5 = 105
21 / 5 = 4.2
21 // 5 = 4
21 % 5 = 1
21 ** 5 = 4084101
Em seguida, vamos explorar os operadores de comparação. Estes operadores comparam dois valores e retornam um valor Booleano (True ou False).
Adicione o seguinte código ao final do seu arquivo operators.py:
## Comparison Operators
print("\n--- Comparison Operators ---")
a = 6
b = 5
print(f'{a} == {b} is {a == b}') ## Equal to
print(f'{a} != {b} is {a != b}') ## Not equal to
print(f'{a} > {b} is {a > b}') ## Greater than
print(f'{a} < {b} is {a < b}') ## Less than
print(f'{a} >= {b} is {a >= b}') ## Greater than or equal to
print(f'{a} <= {b} is {a <= b}') ## Less than or equal to
Salve o arquivo novamente e execute-o a partir do terminal:
python ~/project/operators.py
A saída agora incluirá os resultados das operações de comparação:
21 + 5 = 26
21 - 5 = 16
21 * 5 = 105
21 / 5 = 4.2
21 // 5 = 4
21 % 5 = 1
21 ** 5 = 4084101
--- Comparison Operators ---
6 == 5 is False
6 != 5 is True
6 > 5 is True
6 < 5 is False
6 >= 5 is True
6 <= 5 is False
Você agora utilizou com sucesso os operadores aritméticos e de comparação em um script Python.
Praticar Operadores de Atribuição e Lógicos
Nesta etapa, praticaremos o uso de operadores de atribuição (assignment operators) e operadores lógicos (logical operators). Os operadores de atribuição são usados para atribuir ou atualizar o valor de uma variável, enquanto os operadores lógicos são usados para combinar declarações condicionais.
Continue trabalhando com o arquivo operators.py no editor VS Code.
Primeiro, vamos adicionar exemplos de operadores de atribuição. Estes fornecem uma forma abreviada de realizar uma operação e atribuir o resultado de volta à mesma variável.
Adicione o seguinte código ao final do seu arquivo operators.py:
## Assignment Operators
print("\n--- Assignment Operators ---")
a = 10
b = 3
print(f'Initial a: {a}')
c = a
c += b ## Equivalent to c = c + b
print(f'a += b: {c}')
c = a
c -= b ## Equivalent to c = c - b
print(f'a -= b: {c}')
c = a
c *= b ## Equivalent to c = c * b
print(f'a *= b: {c}')
c = a
c /= b ## Equivalent to c = c / b
print(f'a /= b: {c}')
## Walrus operator (Python 3.8+)
## It assigns a value to a variable as part of a larger expression.
print("\n--- Walrus Operator ---")
text = 'hello python'
if (n := len(text)) > 10:
print(f'The string is long enough ({n} characters)')
Salve o arquivo e execute-o a partir do terminal:
python ~/project/operators.py
Você deverá ver a saída para os operadores de atribuição:
... (output from previous step) ...
--- Assignment Operators ---
Initial a: 10
a += b: 13
a -= b: 7
a *= b: 30
a /= b: 3.3333333333333335
--- Walrus Operator ---
The string is long enough (12 characters)
Agora, vamos adicionar exemplos de operadores lógicos (and, or, not). Estes operadores funcionam com valores Booleanos, mas também podem funcionar com outros tipos. Em Python, valores como 0, None e coleções vazias ('', [], {}) são considerados False. Todos os outros valores são considerados True.
Adicione o seguinte código ao final do seu arquivo operators.py:
## Logical Operators
print("\n--- Logical Operators ---")
x = True
y = False
print(f'{x} and {y} is {x and y}')
print(f'{x} or {y} is {x or y}')
print(f'not {x} is {not x}')
## Evaluation with non-boolean values
a = 10 ## True
b = 0 ## False
print(f'{a} and {b} returns {a and b}') ## Returns the first Falsey value or the last Truthy value
print(f'{a} or {b} returns {a or b}') ## Returns the first Truthy value or the last Falsey value
Salve o arquivo e execute-o novamente:
python ~/project/operators.py
A saída agora incluirá os resultados das operações lógicas:
... (output from previous examples) ...
--- Logical Operators ---
True and False is False
True or False is True
not True is False
10 and 0 returns 0
10 or 0 returns 10
Você praticou agora o uso de operadores de atribuição e lógicos em Python.
Aprender Operadores Bitwise
Nesta etapa, aprenderemos sobre operadores bitwise (bitwise operators). Estes operadores realizam operações diretamente na representação binária (base 2) de inteiros. Isso é útil para manipulação de dados de baixo nível.
Continue editando o arquivo operators.py.
Primeiro, vamos ver a representação binária de alguns números usando a função bin(). O prefixo 0b indica que os dígitos seguintes são binários.
Adicione este código ao final de operators.py:
## Bitwise Operators
print("\n--- Bitwise Operators ---")
a = 5 ## Binary: 0b101
b = 9 ## Binary: 0b1001
print(f'Binary of {a} is {bin(a)}')
print(f'Binary of {b} is {bin(b)}')
## For clarity, let's align them with 4 bits:
## a = 0101
## b = 1001
## Bitwise AND (&): Sets each bit to 1 if both bits are 1.
## 0101 & 1001 = 0001 (Decimal 1)
print(f'{a} & {b} = {a & b}')
## Bitwise OR (|): Sets each bit to 1 if one of the two bits is 1.
## 0101 | 1001 = 1101 (Decimal 13)
print(f'{a} | {b} = {a | b}')
## Bitwise XOR (^): Sets each bit to 1 if only one of the two bits is 1.
## 0101 ^ 1001 = 1100 (Decimal 12)
print(f'{a} ^ {b} = {a ^ b}')
## Bitwise NOT (~): Inverts all the bits.
## ~a is equivalent to -(a+1)
print(f'~{a} = {~a}')
## Left Shift (<<): Shifts bits to the left, filling with zeros.
## Equivalent to multiplying by 2**n.
## 5 << 2 means 0101 becomes 10100 (Decimal 20)
print(f'{a} << 2 = {a << 2}')
## Right Shift (>>): Shifts bits to the right, discarding bits from the right.
## Equivalent to floor division by 2**n.
## 9 >> 2 means 1001 becomes 10 (Decimal 2)
print(f'{b} >> 2 = {b >> 2}')
Salve o arquivo e execute o script a partir do terminal:
python ~/project/operators.py
Você verá a saída demonstrando cada operação bitwise:
... (output from previous steps) ...
--- Bitwise Operators ---
Binary of 5 is 0b101
Binary of 9 is 0b1001
5 & 9 = 1
5 | 9 = 13
5 ^ 9 = 12
~5 = -6
5 << 2 = 20
9 >> 2 = 2
Você aprendeu agora como usar operadores bitwise para manipular inteiros no nível de bits.
Usar Operadores de Associação (Membership) e Identidade (Identity)
Nesta etapa final, abordaremos os operadores de associação (in, not in) e os operadores de identidade (is, is not). Os operadores de associação testam se um valor está presente em uma sequência, enquanto os operadores de identidade verificam se duas variáveis referenciam exatamente o mesmo objeto na memória.
Continue trabalhando com o arquivo operators.py.
Primeiro, vamos adicionar exemplos de operadores de associação. Eles são comumente usados com sequências como listas, tuplas e strings.
Adicione o seguinte código ao final do seu arquivo operators.py:
## Membership Operators
print("\n--- Membership Operators ---")
my_list = [1, 3, 5, 7]
print(f'3 in {my_list} is {3 in my_list}')
print(f'4 not in {my_list} is {4 not in my_list}')
greeting = "hello world"
print(f'"world" in "{greeting}" is {"world" in greeting}')
Salve o arquivo e execute-o:
python ~/project/operators.py
A saída para os operadores de associação será:
... (output from previous steps) ...
--- Membership Operators ---
3 in [1, 3, 5, 7] is True
4 not in [1, 3, 5, 7] is True
"world" in "hello world" is True
Agora, vamos explorar os operadores de identidade. É importante entender a diferença entre is (identidade) e == (igualdade). == verifica se os valores de dois objetos são os mesmos, enquanto is verifica se eles são o mesmo objeto (ou seja, se têm o mesmo endereço de memória).
Adicione o seguinte código ao seu arquivo operators.py:
## Identity Operators
print("\n--- Identity Operators ---")
## For small integers, Python often reuses the same object.
x = 256
y = 256
print(f'x is y (for 256): {x is y}') ## This is often True
## For larger integers, Python may create separate objects.
a = 257
b = 257
print(f'a is b (for 257): {a is b}') ## This is often False
## For mutable objects like lists, they are different objects even if their content is the same.
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(f'list1 == list2: {list1 == list2}') ## Checks for equal content (True)
print(f'list1 is list2: {list1 is list2}') ## Checks for same object (False)
print(f'list1 is not list2: {list1 is not list2}') ## Checks for different objects (True)
Salve o arquivo e execute-o pela última vez:
python ~/project/operators.py
A saída demonstra a diferença entre igualdade e identidade:
... (output from previous examples) ...
--- Identity Operators ---
x is y (for 256): True
a is b (for 257): True
list1 == list2: True
list1 is list2: False
list1 is not list2: True
Você utilizou com sucesso os operadores de associação e identidade, completando sua exploração dos principais tipos de operadores do Python.
Resumo
Neste laboratório, você adquiriu experiência prática com os vários tipos de operadores em Python. Você começou explorando os operadores aritméticos e de comparação fundamentais para realizar cálculos e avaliar condições. Em seguida, praticou o uso de operadores de atribuição para atualizações eficientes de variáveis e operadores lógicos para combinar lógica condicional.
Além disso, você se aprofundou nos operadores bitwise para entender a manipulação de dados de baixo nível e concluiu com os operadores de associação (membership) e identidade (identity) para verificar a presença de itens e a identidade de objetos. Ao escrever e executar código para cada tipo de operador no editor VS Code, você construiu uma base sólida para usar essas ferramentas essenciais em sua futura programação em Python.
