Aprendendo Python Sozinho: Literais e Operadores em Python

Iremos ver nesse post o que são literais e operadores em Python de forma que possamos ter fundamentos sólidos em nossa aprendizagem.

Em resumo: Python, literais são valores fixos que são representados diretamente no código, como números, strings e booleanos. Já os operadores são símbolos especiais que realizam operações entre valores, como adição (+), subtração (-) e comparação (==).

Veja todos os artigos dessa série em: Aprendendo programar Python por conta própria.

Nesse post iremos ver:

1. Literais em Python
2. Operadores em Python
3. Precedência dos Operadores em Python
4. Operadores aritméticos em Python
5. Operadores de atribuição em Python
6. Operadores de atribuição aumentada em Python
7. Operadores de comparação em Python
8. Operadores lógicos
9. Operadores bitwise (ou bit a bit) em Python
10. Operadores de associação em Python
11. Operadores de identidade em Python

1. Literais em Python

Um valor literal é como escrever o número em si dentro do código. Por exemplo, o literal inteiro “5” representa o número 5 e o nome maria representa a string “maria”. É justamente isso e nada mais. Parece uma coisa boba?

Literal, de forma simples, é um valor fixo que é diretamente representado no código. Por exemplo, se eu escrever o número 10 no código, esse é um literal de número inteiro.

Veja também: Aprendendo Python por Conta Própria: Variáveis em Python

Alguns exemplos de literais em Python são:

• Números inteiros: 10, 20, -5
• Números de ponto flutuante: 3.14, 2.5, -0.5
• Strings: “Olá!”, “Python é incrível!”
• Booleanos: True, False
• Listas: [1, 2, 3], [“maçã”, “banana”, “laranja”]
• Dicionários: {“nome”: “João”, “idade”: 25}

Em contraste com as variáveis, os literais 10, 4.4, e “Ola mundo” são valores estáticos pois não mudam durante a operação do programa ou aplicativo. Afinal de contas, 10 irá ser sempre 10, a string “Ola mundo” será sempre isso. Dizemos que literal é uma constante, porque seu valor nunca muda, é bem constante durante todo o código.

Um literal pode ser atribuído a uma variável para armazenar e manipular esse valor posteriormente. Por exemplo,

idade = 10

a variável idade recebe o valor 10. Como o nome diz, a variável pode variar, ela recebe 10 aqui e logo ali passa receber 15, mas o literal 10 não mudou, apenas deixou de estar dentro de uma variável, dando lugar a outro literal, o 15.

x = idade*2

Acima, multiplicamos idade por 2 mas mesmo que a expressão seja calculada e ter resultado 20, ela não será incluída literalmente no código-fonte.

É bom frisar que vimos sobre tipos de dados(string, integer, float, lista, complexo, dicionário e tupla) no post: Aprendendo Python por Conta Própria: O que São Dados e Quais os Tipos em Python?

1.1 Inteiro (Integer) Literal em Python

Um literal inteiro é uma forma de representar um número inteiro diretamente no código e com esses literais inteiros podemos realizar cálculos matemáticos.

Veja,

x = 10
y = -25
z = 0
a = 0O34 # número prefixado por 0o ou 0O é um número inteiro octal em Python
b = 0X1C # número prefixado por 0x ou 0X representa um número inteiro na forma hexedecimal em Python

Acima, para variar, usamos números literais em formato octal e hexadecimal, usamos respectivamente zero+O e zero+X. É bom notar que, mesmo se você usar notação literal octal ou hexadecimal, o Python os trata internamente como do tipo int. Veja,

>>> x = 0O34
>>> print ("0o34 em octal é ", x, type(x))
0o34 em octal é  28 <class 'int'>

1.2 Float Literal em Python

Sabemos que um flot é um número fracionado por um ponto. No mundo real usamos também a vírgula.

x = 25.55
y = 0.05
z = -12.2345
a = 1.23E05 # é a mesma coisa que 123000.00
b = 1.23e-2 # é a mesma coisa que 0.0123

Veja acima que usamos valores como 1.23E05 e 1.23e-2. Onde o número de dígitos antes ou depois da vírgula decimal(nesse caso um ponto) for grande, uma notação científica pode ser usada para deixarmos mais compacta e resumida o literal. O símbolo E ou e seguido de número inteiro positivo ou negativo segue após a parte inteira.

Assim, 1.23e010 é a mesma coisa que 12300000000.0 e 2.6e-3 igual a 0.0026. Faça testes você mesmo no terminal do Python:

>>> 1.23e05
123000.0
>>> 1.23e010
12300000000.0
>>> 2.6e-3
0.0026
>>> 33e4
330000.0
>>> 33e04
330000.0
>>> 33e004
330000.0

Irei usar essa notação científica alguma vez na vida? Não sei, mas vale a pena aprender, vai que né?

1.3 Complexo Literal em Python

Nunca vi nada sobre esse tal de “número complexo” na vida! Mas a explicação é que número(literal) complexo consiste em uma parte real e uma parte imaginária. É escrito na forma “a + bj”, onde “a” é a parte real, “b” é a parte imaginária e “j” é a unidade imaginária. Por exemplo, o número complexo 2 + 3j representa 2 como a parte real e 3 como a parte imaginária.

A explicação abaixo não ajuda muito mas já é um adendo:

Literais complexos em Python são usados quando precisamos lidar com números complexos em cálculos matemáticos ou em problemas que envolvem a parte imaginária, como na análise de sinais, processamento de imagens ou simulações físicas.

Usando type() podemos atestar o que disse acima sobre o formato “a+bj”. Digite type(2+4j) num shell Python e veja,

>>> type(2+4j)
<class 'complex'>
>>> type(4+5j)
<class 'complex'>

1.4 String Literal em Python

Uma literal string é criada, como já vimos em diversos posts dessa série, colocando um texto entre aspas simples ou duplas ou até triplas.

Saiba que se for necessário fazer aspas duplas aparecer como parte da string, a própria string deverá ser colocada entre/dentro aspas simples. Por outro lado, se o texto entre aspas simples tiver que aparecer na tela, a string deverá ser escrita entre/dentro aspas duplas.

>>> var1='Estou aprendendo "Python" '
>>> var2="Novamente, estou aprendendo 'Python' "
>>> print(var1)
Estou aprendendo "Python" 
>>> print (var2)
Novamente, estou aprendendo 'Python' 

Outros exemplos,

>>> var1='Oi!'
>>> var2="Oi!"
>>> var3='''Oi!'''
>>> var4="""Oi!"""

>>> print ("'Oi!' em aspas simples é: ", var1, type(var1))
'Oi!' em aspas simples é:  Oi! <class 'str'>
>>> print ('"Oi!" em aspas duplas é: ', var2, type(var2))
"Oi!" em aspas duplas é:  Oi! <class 'str'>

>>> print (" '''Oi!''' em aspas triplas é: ", var3, type(var3))
 '''Oi!''' em aspas triplas é:  Oi! <class 'str'>

>>> print (' """Oi!""" em aspas triplas  é: ', var4, type(var4))
 """Oi!""" em aspas triplas  é:  Oi! <class 'str'>

1.5 Lista Literal em Python

Como mostramos em nosso post sobre tipos de dados em Python, lista é uma coleção ordenada de elementos e podemos colocar dentro dela números, strings e até mesmo outras listas.

dados=[1,"maria",75.50, True]

Lembre que listas em python ficam dentro de colchetes []. Podemos ver o tipo do “objeto” uysando a função type():

>>> type(dados)
<class 'list'>

1.6 Tuplas Literal em Python

Uma tupla literal em Python é uma sequência ordenada de valores separados por vírgulas, dentro de parênteses ().

dados=(1,"maria",75.50, True)

Vamos confirmar que realmente dados é uma tupla

>>> type(dados)
<class 'tuple'>

1.7 Literal de Dicionário em Python

Um literal de dicionário em Python é uma coleção, um conjunto de itens em pares, isto é, cada item possui “uma chave e seu valor”, onde cada valor é associado a uma chave. Exemplos,

>>> numeros={1:"um", 2:"Dois", 3:"três",4:"quatro"}

Podemos ver que um dicionário é criado usando chaves {} e os pares chave-valor são separados por vírgulas.

Se pesquisarmos pela chave 1 iremos ter como resposta “um”, por 2 termos “dois” e assim por diante. É como um dicionário onde você pode procurar um valor usando uma chave específica.

Vamos validar o tipo do objeto:

>>> type(numeros)
<class 'dict'>

A chave deve ser um objeto imutável. Número, string ou tupla podem ser usados ​​como chave. A chave não pode aparecer mais de uma vez em uma coleção. Se uma chave aparecer mais de uma vez, apenas a última será mantida. Os valores podem ser de qualquer tipo de dados. Um valor pode ser atribuído a mais de uma chave. Por exemplo,

>>> staff={"Maria":"Oficial", "Fernanda":"Gerente", "Regina":"Oficial", "Anita":"Escriturário", "Mário":"Gerente"}

2. Operadores em Python

Operadores são símbolos especiais que realizam operações em valores, como adição, subtração, multiplicação e comparação. Eles permitem que você manipule e compare dados de diferentes maneiras.

Os literais que vimos acima podem ser usados com os operadores para realizar diferentes operações.

2.1 Tipos de operadores em Python

Os tipos de operadores em Python são:

• Operadores Aritméticos: +, -, , /, %, //, *
• Operadores de Atribuição: =, +=, -=, =, /=, %=, //=, *=
• Operadores de Comparação: ==, !=, >, <, >=, <=
• Operadores Lógicos: and, or, not
• Operadores de Identidade: is, is not
• Operadores de Associação: in, not in
• Operadores Bit a Bit: &, |, ^, ~, <<, >>

Vamos dar uma olhada em todos os operadores, um por um.

Operadores aritméticos

Operador	Nome	Exemplo
+	Adição	uma + b = 30	Soma de números
–	Subtração	uma – b = -10	“diminui” números
*	Multiplicação	uma * b = 200	Calcula um números “vezes” outro
/	Divisão	b / a = 2	divide um número pelo outro
%	Módulo	b % a = 0	O operador % em Python é chamado de operador de módulo. Ele retorna o resto da divisão entre dois números. Por exemplo, 7 % 3 retorna 1, pois o resto da divisão de 7 por 3 é igual a 1.
**	Exponenciação	a**b =10**20	usado para realizar a exponenciação, ou seja, calcular a potência de um número. Por exemplo, 2 * 3 retorna 8, pois é o mesmo que 2 elevado à potência de 3.
//	divisão inteira	9//2 = 4	arredonda o resultado para o número inteiro mais próximo que é menor ou igual ao resultado da divisão.

Alguns pontos que requerem nossa atenção:

1. Python tem alguns outros operadores aritméticos. São eles “%” (Módulo), “**” (exponenciação) e “//” (Divisão inteira). Exemplos,
   • Divisão inteira: 9//2 = 4
   • Exponenciação: 10**20 = 100000000000000000000
   • módulo: 10 % 2 = 0
2. Python suporta operações onde os dois operandos podem ser de dois tipos de números diferentes. Em tal situação, o Python amplia o mais estreito dos operandos. Um objeto inteiro é mais estreito que um objeto float e float é mais estreito que um objeto complexo. Conseqüentemente, o resultado da operação aritmética de int e float é um float. O resultado de float e um complexo é um número complexo; da mesma forma, a operação em um número inteiro e um objeto complexo resulta em um objeto complexo.
   • A soma de inteiro e float resulta em um float: 20.5+5 = 25.5
   • somar um float mais um objeto complexo resulta em um número complexo: 10+5j+20.2 = (30.2+5j)
3. Na operação de multiplicação com um operando complexo, o outro operando multiplica tanto a parte real quanto a parte imaginária do objeto complexo.
   • Nesse exemplo, usamos ponto e vírgula para fazer mais de um comando em uma mesma linha: a=10+5j; b=2 ; a*b = (20+10j)
4. Na divisão “/”, o número resultante é negativo se algum dos operandos for negativo. Como o infinito não pode ser armazenado na memória, Python gera ZeroDivisionError se o denominador for 0.
   • O resultado do operador de divisão em Python é sempre flutuante, mesmo que ambos os operandos sejam inteiros.
   • Na divisão, um operando flutuante pode ter uma notação de ponto decimal padrão ou uma notação científica: 2.50/1.25E2 = 0.02
   • Quando um dos operandos é um número complexo, ocorre a divisão entre o outro operando e ambas as partes do objeto do número complexo (real e imaginário): a=7.5+7.5j ; b=2.5 ; a/b = (3+3j)
   • ou se invertermos os operandos acima: b/a = (0.16666666666666666-0.16666666666666666j)
5. Quanto ao operador módulo “%”,
   • Se o numerador for menor que o denominador, o módulo é igual ao numerador: 2%10 = 2
   • Se o denominador for 0, Python gera ZeroDivisionError.
   • Se algum dos operandos for float, o valor do mod será sempre float: 10%2.0 = 0.0
   • Python não aceita números complexos para serem usados ​​como operando na operação de módulo. Ele lança TypeError: tipos de operandos não suportados para %.
6. Quanto à exponenciação,
   • ambos os operandos são inteiros, o resultado também é um inteiro. Caso um deles seja float, o resultado será float. Da mesma forma, se um dos operandos for um número complexo, o operador expoente retornará um número complexo.
   • Se a base for 0, o resultado será 0, e se o índice for 0, o resultado será sempre 1.
7. Quanto à divisão inteira “//”,
   • Se ambos os operandos forem positivos, o operador floor(divisão inteira) retorna um número com a parte fracionária removida dele. Por exemplo, a divisão mínima de 9,8 por 2 retorna 4 (a divisão “/” seria 4,9, mas como // retira a parte fracionária, o resultado é 4).
   • Mas se um dos operandos for negativo, o resultado será arredondado de zero (em direção ao infinito negativo). A divisão mínima de -9,8 por 2 retorna 5 (a divisão pura é -4,9, arredondada de 0).
8. Quanto à operações com números complexos,
   • A adição e subtração de números complexos é uma simples adição/subtração dos respectivos componentes reais e imaginários. Exemplo, a=2.5+3.4j ; b=-3+1.0j ; a+b terá como resultado (-0.5+4.4j)

Operadores de comparação Python

Esses operadores comparam os valores. Eles também são chamados de operadores relacionais.

Vamos ver na tabela exemplos que levando em consideração que a igual a 10 (a=10) e b igual a 20 (b=20).

Operador	Nome	Exemplo
==	Igual	(a == b) não é verdade, é falso, pois a é diferente de b
!=	Não igual	(uma! = b) é verdadeiro, pois a é diferente de b
>	Maior que	(a > b) não é verdade, pois a não é maior que b
<	Menor que	(a < b) é verdadeiro, pois a é maior que b
>=	Melhor que ou igual a	(a >= b) não é verdade.
<=	Menos que ou igual a	(a <= b) é verdadeiro.

Vejamos na prática,

>>> a = 10
>>> b = 8
>>> a > b
True
>>> a < b
False
>>> a == b
False

Em Python, a comparação apenas de objetos de sequência semelhantes pode ser realizada. Um objeto string é comparável apenas a outra string. Uma lista não pode ser comparada com uma tupla, mesmo que ambas tenham os mesmos itens. Por exemplo, a comparação abaixo resultará em erro:

>>> a=(1,2,3)
>>> b=[1,2,3]
>>> a <  b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'tuple' and 'list'

Ao comparar strings temos que ‘BAT’>’BAR’ é verdadeiro, pois  T vem depois de R na ordem Unicode.

Em dois objetos de tupla a=(1,2,4) e b=(1,2,3) se compararmos a>b dará true.

Quanto a Objetos de dicionário, se usarmos “<” ou “>” receberemos erro, mas conseguimos usar “==” e verificará se o comprimento de ambos os itens do dict é o mesmo. Dados a={1:1,2:2} e b={2:2, 1:1, 3:3}, a==b é falso.

Operadores de Atribuição Python

Os operadores de atribuição em Python são usados para atribuir valores a variáveis. O símbolo de igual “=” é usado para atribuição, isto é, o valor da à direita do “=” é atribuído a uma única variável à sua esquerda. Em idade=10 dizemos que a variável idade recebe(=) 10.

O “=” é um símbolo de atribuição simples. Python fornece mais alguns operadores de atribuição para uso avançado. Eles são chamados de operadores de atribuição cumulativos ou aumentados.

Operador	Exemplo	A mesma coisa que	Resultado
=	a = 10	a = 10	a recebe 10
+=	a += 30	a = a + 30	a é igual a ele mesmo somado com 30. Resultado é 40, pois a é 10 + 30.
-=	a -= 15	a = a – 15	a é igual a ele mesmo menos 15.
*=	a *= 10	a = a * 10	a é igual a ele mesmo vezes 10
/=	a /= 5	a = a / 5	a é igual a ele mesmo dividido por 5
%=	a %= 5	a = a % 5	resultado é zero. Se a=10 então ele é igual ao resto da divisão de 10 por 5.
**=	a **= 4	a = a ** 4
//=	a //= 5	a = a // 5
&=	a &= 5	a = a & 5
|=	a |= 5	a = a | 5
^=	a ^= 5	a = a ^ 5
>>=	a >>= 5	a = a >> 5
<<=	a <<= 5	a = a << 5

Operadores bit a bit em Python

Os operadores bit a bit em Python são usados para realizar operações lógicas bit a bit em números inteiros.

Obs.: Irei usar esse operador bit a bit alguma vez na vida?

As operações lógicas bit a bit em números inteiros são operações que são realizadas em cada bit individual dos números. Essas operações incluem AND, OR e XOR, e elas manipulam os bits de acordo com as regras lógicas correspondentes.

Todo número tem seu formato binário. Na verdade, o computador só entende binário então todas as entradas a serem processadas são convertidas em binários. Exemplo,

1 em binário: 0001
5 em binário: 0101
10 em binário: 1010
25 em binário: 11001

Você pode obter o binário de cada número com a função bin(), o binário de 50 é 110010:

>>> bin(50)
'0b110010'

Como que 50 é 110010? É simples, da direita para a esquerda, a primeira casa é igual a 1, a segunda a 2, terceira a 4, quinta a 8, sexta a 16, sétima a 32… Toda vez que o número do binário for 1 então somamos esses valores. Então,

Bit		Soma
1	igual a 32 e soma	32
1	igual a 16 e soma	16
0	igual a 8 mas não soma por ser zero	–
0	igual a 4 mas não soma por ser igual a zero	–
1	igual a 2 e soma	2
0	igual a 1 mas não soma por ser zero	–

32 + 16 + 2 = 50

Voltando ao assunto, ao invés trabalhar com o número em seu formato que já conhecemos, operadores bit a bit trabalham com números em formato binário. Os inteiros são  tratados como uma sequência de bits.

Operador	Nome	Exemplo
&	AND	a & b
|	OR	a | b
^	XOR	a ^ b
~	NOT	~a
<<	Zero fill left shift	a << 3
>>	Signed right shift	a >> 3

Explicando sobre esses operadores bit a bit ou chamados de bitwise,

• “&” (AND bit a bit): Retorna um número que representa os bits que estão definidos tanto no primeiro quanto no segundo número.
• “|” (OR bit a bit): Retorna um número que representa os bits que estão definidos no primeiro número ou no segundo número, ou em ambos.
• “^” (XOR bit a bit): Retorna um número que representa os bits que estão definidos apenas no primeiro número ou apenas no segundo número, mas não em ambos.
• “~” (NOT bit a bit): Inverte todos os bits de um número, transformando 0 em 1 e 1 em 0.
• “<<” (Deslocamento à esquerda): Desloca os bits de um número para a esquerda, adicionando zeros à direita.
• “>>” (Deslocamento à direita): Desloca os bits de um número para a direita, removendo os bits à direita.

Você pode converter um número decimal em binário da seguinte usando bin(), como em:

>>> bin(5)
'0b101'
>>> bin(3)
'0b11'

Podemos ver que o binário do decimal 5 é 101 e de 3 é 11.

Veja exemplos de operações bit a bit em python com explicação,

1. Operador AND (&):

• 5 & 3 = 1
  • O operador AND compara cada bit dos números e retorna 1 apenas quando ambos os bits são 1. No caso, o bit mais à direita é o único bit em comum entre 5 (101 em binário) e 3 (011 em binário), resultando em 1 (001 em binário).

1. Operador OR (|):

• 5 | 3 = 7
  • O operador OR compara cada bit dos números e retorna 1 quando pelo menos um dos bits é 1. No caso, os bits mais à direita são iguais a 1 tanto em 5 (101 em binário) quanto em 3 (011 em binário), resultando em 7 (111 em binário).

1. Operador XOR (^):

• 5 ^ 3 = 6
  • O operador XOR compara cada bit dos números e retorna 1 apenas quando os bits são diferentes. No caso, os bits mais à direita são diferentes entre 5 (101 em binário) e 3 (011 em binário), resultando em 6 (110 em binário).

1. Deslocamento para a esquerda (<<):

• 5 << 2 = 20
  • O deslocamento para a esquerda move todos os bits de um número para a esquerda, adicionando zeros à direita. No caso, deslocar o número binário de 5 (101) duas posições para a esquerda resulta em 20 (10100).

1. Deslocamento para a direita (>>):

• 5 >> 2 = 1
  • O deslocamento para a direita move todos os bits de um número para a direita, preenchendo os bits à esquerda com zeros. No caso, deslocar o número binário de 5 (101) duas posições para a direita resulta em 1 (001).

---

Falando um pouco sobre o operador bitwise NOT ou ~

O operador ~ inverte cada bit para que 1 seja substituído por 0 e 0 por 1 e retorne o complemento do número original.

É bom sempre trabalharmos em 8 bits, por exemplo, o número 2 é 10 em binário, mas aqui podemos acrescentar 6 zeros à esquerda para formar uma representação de 8 bits: 00000010.

Mas, como funciona o bitwise NOT em Python? Python utiliza um método chamado complemento de 2 para representar números inteiros. Esse método é uma maneira de representar números negativos em binário.

1. Números Positivos: Para números inteiros positivos, a representação em complemento de 2 é obtida simplesmente invertendo os bits. Por exemplo, se tivermos o número binário 00101011, a sua representação em complemento de 2 seria 11010100.
2. Números Negativos: Para representar números negativos, como -x, onde “-x” representa qualquer número negativo, primeiro calculamos (x-1) em binário e, em seguida, invertemos todos os bits. Por exemplo, se tivermos o número -5, representado como em complemento de 2 ficaria 11111011; (em binário) , inverteríamos todos os bits, resultando em 00000101.

>>> ~5  # NOT em numero positivo
-6
>>> ~-5  # NOT em numero negativo
4
>>> bin(~5) # binario de NOT em número positivo
'-0b110'
>>> bin(~-5) # binario de NOT em número negativo
'0b100'

---

Falando um pouco sobre os operadores << e >>

Para relembrar, << e >> são chamados de operadores de deslocamento de bits.

Eles são usados para mover os bits dos números para a esquerda ou para a direita, respectivamente.

• << move os bits dos números para a esquerda.  “x << 2” causa dois bits da representação binária para a direita.
• >> mover os bits dos números para a direita.  “x >> 2” causa dois bits da representação binária para a esquerda.

>>> 4<<4
64
>>> 4<<1
8
>>> 4>>4
0
>>> 60>>4
3

Veja com 60 << 2

>>> 60 << 2
240

Como funciona?

0011 1100
<<
    2
-------------
1111 0000

Vamos passar pelo processo passo a passo:

Vamos passar pelo processo passo a passo:

1. Número Binário Original: 0011 1100
2. Deslocamento à Esquerda por 2 Posições:
   • O deslocamento move todos os bits dois lugares para a esquerda, introduzindo zeros à direita.
   • 0011 1100 << 2 resulta em 1111 0000.

Esse tipo de operação é frequentemente usado em programação para realizar multiplicação por potências de 2. No exemplo dado, é equivalente a multiplicar o número original por 2 elevado à potência de 2 (2^2).

Operadores Lógicos Python

Os operadores lógicos são usados para combinar ou avaliar condições.

Operador	Nome	Exemplo
and	E	a and b	O operador “and” retorna True se ambas as condições forem verdadeiras.
or	OU	a or b	O operador “or” retorna True se pelo menos uma das condições for verdadeira.
not	NÂO	not(a)	O operador “not” inverte o valor de uma condição, retornando True se a condição for falsa e False se a condição for verdadeira.

Com os operadores lógicos podemos comparar mais de um termo, fazermos comparações compostas.

>>> a < b and b < c
True

>>> a < b and b == c 
False

>>> a < b or  b == c 
True

Para ficar mais claro sobre os resultados, passo as tabelas abaixo.

A expressão “x and y”, Python avalia primeiro “x”. Se “x” for falso, retornará falso e parará a avaliação; mas se “x” for verdadeiro então “y” será avaliado e o valor resultante será retornado.

a	b	a and b
F	F	F
F	T	F
T	F	F
T	T	T

A expressão “x or y” avalia primeiro “x”; se “x” for verdadeiro, seu valor será retornado; caso contrário, “y” será avaliado e o valor resultante será retornado.

a	b	a or b
F	F	F
F	T	T
T	F	F
T	T	T

a	not (a)
F	T
T	F

Operadores de associação Python

Os operadores de associação são usados para verificar se um valor está presente em uma sequência, como uma lista, tupla ou string. Em outras palavras, operadores de associação são usados para saber se um item faz parte(está associado) de um conjunto, se ele é membro.

Operador	Descrição	Exemplo
in	Retorna True se encontrar uma variável na sequência especificada, caso contrário, retorna false.	a in b
not in	retorna True se não encontrar uma variável na sequência especificada e false caso contrário.	a not in b

Veja alguns exemplos na prática,

1. Verificar se um elemento está presente em uma lista:
   numeros = [1, 2, 3, 4, 5]
   print(3 in numeros) # Saída: True
   Aqui, estamos verificando se o número 3 está presente na lista numeros. Como o número está na lista, o resultado é True.
2. Verificar se um elemento não está presente em uma tupla:
   frutas = (“maçã”, “banana”, “laranja”)
   print(“uva” not in frutas) # Saída: True
   Nesse exemplo, estamos verificando se a fruta “uva” não está presente na tupla frutas. Como a fruta não está na tupla, o resultado é True.

O uso de operadores in e not in com objeto de dicionário é permitido. No entanto, o Python verifica a associação apenas com a coleção de chaves e não de valores.

Operadores de identidade Python

os operadores de identidade são usados para comparar se dois objetos têm a mesma identidade, ou seja, se eles são o mesmo objeto na memória.

Operador	Descrição	Exemplo
is	Retorna True se ambas as variáveis ​​forem o mesmo objeto e false caso contrário. is = é	a is b
is not	Retorna True se ambas as variáveis ​​não forem o mesmo objeto e false caso contrário. is not = não é	a is not b

Veja alguns exemplos usando operadores de identidade em Python

1. Verificar se duas variáveis se referem ao mesmo objeto:
   x = [1, 2, 3]
   y = x
   print(x is y) # Saída: True
   Nesse exemplo, as variáveis x e y estão se referindo ao mesmo objeto na memória, pois y é igual a x(y=x). Portanto, o resultado é True.
2. Verificar se duas variáveis se referem a objetos diferentes:
   a = “Ola”
   b = “Mundo”
   print(a is not b) # Saída: True
   Nesse caso, as variáveis a e b estão se referindo a objetos diferentes na memória. Portanto, o resultado é True. Veja que usamos is not.

2.2 Precedência de Operadores Python

Imagina essa operação “2+3*5”. O que será calculado primeiro, 2+3 ou 3*5? Nesse caso será o 3*5, pois multiplicação tem prioridade(precedência) sobre a adição.

>>> 2+3*5
17

Agora, se envolvermos a soma entre () ela passa a ter precedência.

>>> (2+3)*5
25

Segundo o dicionário dicio.com, precedência é:

Estado daquilo que, por ser muito importante, precisa aparecer em primeiro lugar; prioridade.

A precedência do operador em Python determina a ordem em que os operadores são avaliados em uma expressão. Alguns operadores têm prioridade sobre outros. Por exemplo, operadores aritméticos têm precedência sobre operadores de comparação. É importante entender a precedência dos operadores para garantir que as expressões sejam avaliadas corretamente.

Se uma determinada expressão contém vários operadores, o resultado será determinado pela ordem de precedência. Onde os colchetes “()” são avaliados primeiro, os operadores de divisão e multiplicação em seguida, seguidos pelos operadores de adição e subtração.

Além da prioridade dos operadores, há uma outra precedência chamada de associativa que é quando todos os operadores contêm a mesma prioridade/precedência, então o operador da esquerda é avaliado antes do da direita. Exemplo, em 10/5*4 a divisão tem a mesma precedência que a multiplicação, nesse caso, o cálculo se dá da esquerda para a direita (por associação).

>>> 10/5*4
8.0

Veja tabela de precedência de operadores abaixo,

A tabela a seguir lista todos os operadores em Python em ordem decrescente de precedência. Os operadores na mesma célula da coluna Operadores têm a mesma precedência.

Precedência	Operador e Descrição
1	(),[], {} Parênteses e colchetes
2	[index], [index:index] Assinatura, fatiamento(slicing),
3	await x expressão de espera
4	** Exponenciação
5	+x, -x, ~x Positivo, negativo, bitwise NOT
6	*, @, /, //, % Multiplicação, multiplicação de matrizes, divisão, divisão de piso, resto(módulo)
7	+, – Addição e subtração
8	<<, >> Mudanças à esquerda, mudanças à direita
9	& Bitwise AND
10	^ Bitwise XOR
11	| Bitwise OR
12	in, not in, is, is not, <, <=, >, >=, !=, == Comparações, incluindo testes de adesão e testes de identidade
13	not x Booleano NOT
14	and Booleano AND
15	or Booleano OR
16	if – else expressão condicional
17	lambda expressão lambda
18	:= Operador de morsa(Walrus operator)

Exemplos de operações com precedência,

a = 20
b = 10
c = 15
d = 5
e = 0

e = (a + b) * c / d       #( 30 * 15 ) / 5
e = ((a + b) * c) / d     # (30 * 15 ) / 5
e = (a + b) * (c / d);    # (30) * (15/5)
e = a + (b * c) / d;      #  20 + (150/5)

Isso terá o seguinte resultado,

Valor de (a + b) * c / d   é  90.0
Valor de ((a + b) * c) / d é  90.0
Valor de (a + b) * (c / d) é  90.0
Valor de a + (b * c) / d   é  50.0

Links relacionados:

• Aprendendo Python por Conta Própria: O que São Dados e Quais os Tipos em Python?
• Aprendendo Python por Conta Própria: Variáveis em Python
• Aprendendo Python por Conta Própria: Regras de Escrita – Sintaxe
• Aprendendo Python por Conta Própria: Escolhendo um Programa IDE
• Aprendendo Python por Conta Própria: Instalar Python no Linux e Windows e Acessar o REPL