Operadores de Atribuições e Relacionais
Operadores de Atribuição
Os operadores de atribuição são usados para atribuir valores a variáveis, permitindo que o programador manipule os dados de maneira eficiente. O operador básico, e o mais simples, é o símbolo de igualdade =, que realiza a atribuição direta de um valor a uma variável. No entanto, além desse operador básico, Python também possui operadores de atribuição compostos, que combinam a atribuição com operações matemáticas ou lógicas, proporcionando uma maneira mais compacta e eficiente de realizar cálculos ou modificações em variáveis de forma direta.
Esses operadores compostos economizam linhas de código e ajudam a melhorar a legibilidade ao realizar operações como adição, subtração, multiplicação e divisão diretamente dentro da atribuição.
| Operador | Descrição | Exemplo | ||
|---|---|---|---|---|
| = | atribuição |
|
||
| += | adição |
|
||
| -= | subtração |
|
||
| x*=2 | multiplicação |
|
||
| /= | divisão |
|
||
| //= | divisão inteira |
|
||
| **= | exponenciação |
|
||
| %= | resto da divisão |
|
Operadores Relacionais
Os operadores relacionais são usados para comparar dois valores, ajudando a estabelecer relações entre eles. Eles retornam um valor booleano, ou seja, True ou False, dependendo do resultado da comparação realizada. Dessa forma, esses operadores desempenham um papel crucial na avaliação de condições dentro de um programa. Além disso, eles são essenciais para controlar fluxos de execução em estruturas condicionais, como if, e em loops, como while e for, permitindo que o código tome decisões baseadas nas relações entre os valores envolvidos.
| Operador | Descrição | Exemplo | ||
|---|---|---|---|---|
| == | igual a |
|
||
| != | diferente de |
|
||
| > | maior que |
|
||
| >= | maior ou igual a |
|
||
| < | menor que |
|
||
| <= | menor ou igual |
|
Operadores In e Not
Os operadores in e not in são utilizados para verificar a pertinência ou ausência de um elemento dentro de uma sequência (como uma lista, tupla, string, etc.). Eles retornam um valor booleano (True ou False) com base na avaliação de inclusão ou exclusão de um item dentro da sequência.
In retorna True caso contenha o valor
|
1 2 3 4 5 6 7 8 9 |
hortifruti = ['banana', 'morango', 'abacate','pera'] print('banana' in hortifruti) print('acerola' in hortifruti) """ Resultado: True False """ |
Not In retorna True caso não contenha o valor
|
1 2 3 4 5 6 7 8 9 |
hortifruti = ['banana', 'morango', 'abacate','pera'] print('banana' not in hortifruti) print('acerola' not in hortifruti) """ Resultado: False True """ |
Operadores Is e Is Not
Os operadores is e is not são usados para comparar identidade de objetos, ou seja, se duas variáveis referenciam o mesmo objeto na memória. Diferentemente dos operadores relacionais, que comparam os valores de dois objetos, o is e is not comparam as localizações de memória dos objetos. Essa comparação é fundamental quando queremos saber se duas variáveis estão apontando para a mesma posição de memória, e não apenas se os valores armazenados nelas são iguais.
Is
|
1 2 3 4 5 6 7 8 9 |
dois_igual_a_dois = 2 == 2 dois_maior_quatro = 2 > 4 print("resultado: ",dois_igual_a_dois is dois_maior_quatro) """ Resultado: resultado: False """ |
Is Not
|
1 2 3 4 5 6 7 8 |
dois_igual_a_dois = 2 == 2 dois_maior_quatro = 2 > 4 print("resultado: ",dois_igual_a_dois is not dois_maior_quatro) """ Resultado: resultado: True """ |
Operadores And, Or, Not e Xor
Os operadores lógicos no Python são usados para combinar expressões booleanas e tomar decisões lógicas com base em condições. Eles trabalham com valores verdadeiros (True) ou falsos (False) e são fundamentais para o controle de fluxo e para criar condições complexas.
Em outras palavras, ao usar operadores lógicos, o programador pode definir condições mais elaboradas, criando fluxos de execução mais flexíveis e adaptáveis. Eles são, portanto, cruciais para garantir que o código execute de maneira correta, dependendo das situações que surgem durante a execução do programa.
Observação: Xor também é conhecido como “ou exclusivo“.
Operador Lógico AND
| A | B | A and B | ||
|---|---|---|---|---|
| True | True |
|
||
| True | False |
|
||
| False | True |
|
||
| False | False |
|
Perceba que em AND o resultado é True apenas em “True and True”
Operador Lógico OR
| A | B | A or B | ||
|---|---|---|---|---|
| True | True |
|
||
| True | False |
|
||
| False | True |
|
||
| False | False |
|
Perceba que em OR o resultado é False apenas em “False or False”
Operador Lógico XOR
| A | B | A xor B | ||
|---|---|---|---|---|
| True | True |
|
||
| True | False |
|
||
| False | True |
|
||
| False | False |
|
Perceba que em XOR o resultado é True apenas quando são valores opostos uma ao outro : “True xor False” e “False xor True”
Operador NOT
O operador not em Python é um operador lógico utilizado para inverter o valor de uma expressão booleana. Ele funciona de forma simples: se a expressão for verdadeira, o operador not a transforma em falsa; se for falsa, o operador a transforma em verdadeira. Dessa forma, ele realiza a negação do valor lógico de uma expressão, proporcionando uma maneira simples e eficiente de inverter o estado de uma condição.
Portanto, o operador not é uma ferramenta poderosa para quem deseja trabalhar com expressões booleanas de maneira flexível e direta.
| A | NOT A | ||
|---|---|---|---|
| True |
|
||
| False |
|
Perceba que em NOT inverte o resultado