\/\/<\/td> divis\u00e3o inteira<\/td> 9\/\/2 = 4<\/td> arredonda o resultado para o n\u00famero inteiro mais pr\u00f3ximo que \u00e9 menor ou igual ao resultado da divis\u00e3o.<\/td><\/tr><\/tbody><\/table>Operadores Aritm\u00e9ticos Python<\/figcaption><\/figure>\n\n\n\nAlguns pontos que requerem nossa aten\u00e7\u00e3o:<\/p>\n\n\n\n
\nPython tem alguns outros operadores aritm\u00e9ticos. S\u00e3o eles “%” (M\u00f3dulo), “**” (exponencia\u00e7\u00e3o) e “\/\/” (Divis\u00e3o inteira). Exemplos, \n\nDivis\u00e3o inteira: 9\/\/2 = 4<\/kbd><\/li>\n\n\n\nExponencia\u00e7\u00e3o: 10**20 = 100000000000000000000<\/kbd><\/li>\n\n\n\nm\u00f3dulo: 10 % 2 = 0<\/kbd><\/li>\n<\/ul>\n<\/li>\n\n\n\nPython suporta opera\u00e7\u00f5es onde os dois operandos podem ser de dois tipos de n\u00fameros diferentes. Em tal situa\u00e7\u00e3o, o Python amplia o mais estreito dos operandos. Um objeto inteiro \u00e9 mais estreito que um objeto float e float \u00e9 mais estreito que um objeto complexo. Conseq\u00fcentemente, o resultado da opera\u00e7\u00e3o aritm\u00e9tica de int e float \u00e9 um float. O resultado de float e um complexo \u00e9 um n\u00famero complexo; da mesma forma, a opera\u00e7\u00e3o em um n\u00famero inteiro e um objeto complexo resulta em um objeto complexo.\n\nA soma de inteiro e float resulta em um float: 20.5+5 = 25.5<\/kbd><\/li>\n\n\n\nsomar um float mais um objeto complexo resulta em um n\u00famero complexo: 10+5j+20.2 = (30.2+5j)<\/kbd><\/li>\n<\/ul>\n<\/li>\n\n\n\nNa opera\u00e7\u00e3o de multiplica\u00e7\u00e3o com um operando complexo, o outro operando multiplica tanto a parte real quanto a parte imagin\u00e1ria do objeto complexo. \n\nNesse exemplo, usamos ponto e v\u00edrgula para fazer mais de um comando em uma mesma linha: a=10+5j; b=2 ; a*b = (20+10j)<\/kbd><\/li>\n<\/ul>\n<\/li>\n\n\n\nNa divis\u00e3o “\/”, o n\u00famero resultante \u00e9 negativo se algum dos operandos for negativo. Como o infinito n\u00e3o pode ser armazenado na mem\u00f3ria, Python gera ZeroDivisionError se o denominador for 0.\n\nO resultado do operador de divis\u00e3o em Python \u00e9 sempre flutuante, mesmo que ambos os operandos sejam inteiros.<\/li>\n\n\n\n Na divis\u00e3o, um operando flutuante pode ter uma nota\u00e7\u00e3o de ponto decimal padr\u00e3o ou uma nota\u00e7\u00e3o cient\u00edfica: 2.50\/1.25E2 = 0.02<\/kbd><\/li>\n\n\n\nQuando um dos operandos \u00e9 um n\u00famero complexo, ocorre a divis\u00e3o entre o outro operando e ambas as partes do objeto do n\u00famero complexo (real e imagin\u00e1rio): a=7.5+7.5j ; b=2.5 ; a\/b = (3+3j)<\/kbd> <\/li>\n\n\n\nou se invertermos os operandos acima: b\/a = (0.16666666666666666-0.16666666666666666j)<\/kbd><\/li>\n<\/ul>\n<\/li>\n\n\n\nQuanto ao operador m\u00f3dulo “%”,\n\nSe o numerador for menor que o denominador, o m\u00f3dulo \u00e9 igual ao numerador: 2%10 = 2<\/kbd><\/li>\n\n\n\nSe o denominador for 0, Python gera ZeroDivisionError.<\/li>\n\n\n\n Se algum dos operandos for float, o valor do mod ser\u00e1 sempre float: 10%2.0 = 0.0<\/kbd><\/li>\n\n\n\nPython n\u00e3o aceita n\u00fameros complexos para serem usados \u200b\u200bcomo operando na opera\u00e7\u00e3o de m\u00f3dulo. Ele lan\u00e7a TypeError: tipos de operandos n\u00e3o suportados para %<\/em>.<\/li>\n<\/ul>\n<\/li>\n\n\n\nQuanto \u00e0 exponencia\u00e7\u00e3o,\n\nambos os operandos s\u00e3o inteiros, o resultado tamb\u00e9m \u00e9 um inteiro. Caso um deles seja float, o resultado ser\u00e1 float. Da mesma forma, se um dos operandos for um n\u00famero complexo, o operador expoente retornar\u00e1 um n\u00famero complexo.<\/li>\n\n\n\n Se a base for 0, o resultado ser\u00e1 0, e se o \u00edndice for 0, o resultado ser\u00e1 sempre 1.<\/li>\n<\/ul>\n<\/li>\n\n\n\n Quanto \u00e0 divis\u00e3o inteira “\/\/”,\n\nSe ambos os operandos forem positivos, o operador floor(divis\u00e3o inteira) retorna um n\u00famero com a parte fracion\u00e1ria removida dele. Por exemplo, a divis\u00e3o m\u00ednima de 9,8 por 2 retorna 4 (a divis\u00e3o “\/” seria 4,9<\/strong>, mas como \/\/ retira a parte fracion\u00e1ria, o resultado \u00e9 4).<\/li>\n\n\n\nMas se um dos operandos for negativo, o resultado ser\u00e1 arredondado de zero (em dire\u00e7\u00e3o ao infinito negativo). A divis\u00e3o m\u00ednima de -9,8 por 2 retorna 5 (a divis\u00e3o pura \u00e9 -4,9<\/strong>, arredondada de 0).<\/li>\n<\/ul>\n<\/li>\n\n\n\nQuanto \u00e0 opera\u00e7\u00f5es com n\u00fameros complexos, \n\nA adi\u00e7\u00e3o e subtra\u00e7\u00e3o de n\u00fameros complexos \u00e9 uma simples adi\u00e7\u00e3o\/subtra\u00e7\u00e3o dos respectivos componentes reais e imagin\u00e1rios. Exemplo, a=2.5+3.4j ; b=-3+1.0j ; a+b<\/strong> ter\u00e1 como resultado (-0.5+4.4j)<\/strong><\/li>\n<\/ul>\n<\/li>\n<\/ol>\n\n\n\nOperadores de compara\u00e7\u00e3o Python<\/h4>\n\n\n\n Esses operadores comparam os valores. Eles tamb\u00e9m s\u00e3o chamados de operadores relacionais.<\/p>\n\n\n\n
Vamos ver na tabela exemplos que levando em considera\u00e7\u00e3o que a<\/strong> igual a 10<\/strong> (a=10) e b<\/strong> igual a 20 <\/strong>(b=20).<\/p>\n\n\n\nOperador<\/th> Nome<\/th> Exemplo<\/th><\/tr> ==<\/td> Igual<\/td> (a == b) n\u00e3o \u00e9 verdade, \u00e9 falso, pois a<\/strong> \u00e9 diferente de b<\/strong><\/td><\/tr>!=<\/td> N\u00e3o igual<\/td> (uma! = b) \u00e9 verdadeiro, pois a<\/strong> \u00e9 diferente de b<\/strong><\/td><\/tr>><\/td> Maior que<\/td> (a > b) n\u00e3o \u00e9 verdade, pois a<\/strong> n\u00e3o \u00e9 maior que b<\/strong><\/td><\/tr><<\/td> Menor que<\/td> (a < b) \u00e9 verdadeiro, pois a<\/strong> \u00e9 maior que b<\/strong><\/td><\/tr>>=<\/td> Melhor que ou igual a<\/td> (a >= b) n\u00e3o \u00e9 verdade.<\/td><\/tr> <=<\/td> Menos que ou igual a<\/td> (a <= b) \u00e9 verdadeiro.<\/td><\/tr><\/tbody><\/table>Operadores de compara\u00e7\u00e3o Python<\/figcaption><\/figure>\n\n\n\nVejamos na pr\u00e1tica,<\/p>\n\n\n\n
>>> a = 10\n>>> b = 8\n>>> a > b\nTrue\n>>> a < b\nFalse\n>>> a == b\nFalse<\/pre>\n\n\n\nEm Python, a compara\u00e7\u00e3o apenas de objetos de sequ\u00eancia semelhantes pode ser realizada. Um objeto string \u00e9 compar\u00e1vel apenas a outra string. Uma lista n\u00e3o pode ser comparada com uma tupla, mesmo que ambas tenham os mesmos itens. Por exemplo, a compara\u00e7\u00e3o abaixo resultar\u00e1 em erro:<\/p>\n\n\n\n
>>> a=(1,2,3)\n>>> b=[1,2,3]\n>>> a < b\nTraceback (most recent call last):\n File "<stdin>", line 1, in <module>\nTypeError: '<' not supported between instances of 'tuple' and 'list'<\/pre>\n\n\n\nAo comparar<\/strong> strings<\/strong> temos que ‘BAT’>’BAR’ \u00e9 verdadeiro, pois T vem depois de R na ordem Unicode.<\/p>\n\n\n\nEm dois objetos de tupla a=(1,2,4)<\/strong> e b=(1,2,3) <\/strong> se compararmos a>b<\/strong> dar\u00e1 true.<\/p>\n\n\n\nQuanto a Objetos de dicion\u00e1rio, se usarmos “<” ou “>” receberemos erro, mas conseguimos usar “==” e verificar\u00e1 se o comprimento de ambos os itens do dict \u00e9 o mesmo. Dados a={1:1,2:2}<\/strong> e b={2:2, 1:1, 3:3}<\/strong>, a==b <\/strong>\u00e9 falso.<\/p>\n\n\n\nOperadores de Atribui\u00e7\u00e3o Python<\/h4>\n\n\n\n Os operadores de atribui\u00e7\u00e3o em Python s\u00e3o usados para atribuir valores a vari\u00e1veis. O s\u00edmbolo de igual “=” \u00e9 usado para atribui\u00e7\u00e3o, isto \u00e9, o valor da \u00e0 direita do “=” \u00e9 atribu\u00eddo a uma \u00fanica vari\u00e1vel \u00e0 sua esquerda. Em idade=10 <\/strong>dizemos que a vari\u00e1vel idade <\/strong>recebe(=) 10.<\/strong><\/p>\n\n\n\nO “=” \u00e9 um s\u00edmbolo de atribui\u00e7\u00e3o simples. Python fornece mais alguns operadores de atribui\u00e7\u00e3o para uso avan\u00e7ado. Eles s\u00e3o chamados de operadores de atribui\u00e7\u00e3o cumulativos ou aumentados.<\/p>\n\n\n\nOperador<\/th> Exemplo<\/th> A mesma coisa que<\/th> Resultado<\/strong><\/td><\/tr>=<\/td> a = 10<\/td> a = 10<\/td> a<\/strong> recebe 10<\/strong><\/td><\/tr>+=<\/td> a += 30<\/td> a = a + 30<\/td> a <\/strong>\u00e9 igual a ele mesmo somado com 30. Resultado \u00e9 40, pois a<\/strong> \u00e9 10 + 30.<\/td><\/tr>-=<\/td> a -= 15<\/td> a = a – 15<\/td> a <\/strong>\u00e9 igual a ele mesmo menos 15. <\/td><\/tr>*=<\/td> a *= 10<\/td> a = a * 10<\/td> a <\/strong>\u00e9 igual a ele mesmo vezes 10<\/td><\/tr>\/=<\/td> a \/= 5<\/td> a = a \/ 5<\/td> a <\/strong>\u00e9 igual a ele mesmo dividido por 5<\/td><\/tr>%=<\/td> a %= 5<\/td> a = a % 5<\/td> resultado \u00e9 zero. Se a=10 ent\u00e3o ele \u00e9 igual ao resto da divis\u00e3o de 10 por 5.<\/td><\/tr> **=<\/td> a **= 4<\/td> a = a ** 4<\/td> <\/td><\/tr> \/\/=<\/td> a \/\/= 5<\/td> a = a \/\/ 5<\/td> <\/td><\/tr> &=<\/td> a &= 5<\/td> a = a & 5<\/td> <\/td><\/tr> |=<\/td> a |= 5<\/td> a = a | 5<\/td> <\/td><\/tr> ^=<\/td> a ^= 5<\/td> a = a ^ 5<\/td> <\/td><\/tr> >>=<\/td> a >>= 5<\/td> a = a >> 5<\/td> <\/td><\/tr> <<=<\/td> a <<= 5<\/td> a = a << 5<\/td> <\/td><\/tr><\/tbody><\/table>Operadores de Atribui\u00e7\u00e3o Python<\/figcaption><\/figure>\n\n\n\n<\/p>\n\n\n\n
<\/p>\n\n\n\n
Operadores bit a bit em Python<\/h4>\n\n\n\n Os operadores bit a bit em Python s\u00e3o usados para realizar opera\u00e7\u00f5es l\u00f3gicas bit a bit em n\u00fameros inteiros. <\/p>\n\n\n\n
Obs.: Irei usar esse operador bit a bit alguma vez na vida?<\/mark><\/p>\n\n\n\nAs opera\u00e7\u00f5es l\u00f3gicas bit a bit em n\u00fameros inteiros s\u00e3o opera\u00e7\u00f5es que s\u00e3o realizadas em cada bit individual dos n\u00fameros. Essas opera\u00e7\u00f5es incluem AND, OR e XOR, e elas manipulam os bits de acordo com as regras l\u00f3gicas correspondentes. <\/p>\n\n\n\n
Todo n\u00famero tem seu formato bin\u00e1rio. Na verdade, o computador s\u00f3 entende bin\u00e1rio ent\u00e3o todas as entradas a serem processadas s\u00e3o convertidas em bin\u00e1rios. Exemplo,<\/p>\n\n\n\n
1 em bin\u00e1rio: 0001\n5 em bin\u00e1rio: 0101\n10 em bin\u00e1rio: 1010\n25 em bin\u00e1rio: 11001<\/pre>\n\n\n\nVoc\u00ea pode obter o bin\u00e1rio de cada n\u00famero com a fun\u00e7\u00e3o bin()<\/strong><\/em>, o bin\u00e1rio de 50 \u00e9 110010:<\/p>\n\n\n\n>>> bin(50)\n'0b110010'<\/pre>\n\n\n\nComo que 50 \u00e9 110010? \u00c9 simples, da direita para a esquerda, a primeira casa \u00e9 igual a 1, a segunda a 2, terceira a 4, quinta a 8, sexta a 16, s\u00e9tima a 32… Toda vez que o n\u00famero do bin\u00e1rio for 1 ent\u00e3o somamos esses valores. Ent\u00e3o,<\/p>\n\n\n\nBit<\/strong><\/td><\/td> Soma<\/strong><\/td><\/tr>1<\/td> igual a 32 e soma<\/td> 32<\/td><\/tr> 1<\/td> igual a 16 e soma <\/td> 16<\/td><\/tr> 0<\/td> igual a 8 mas n\u00e3o soma por ser zero<\/td> –<\/td><\/tr> 0<\/td> igual a 4 mas n\u00e3o soma por ser igual a zero<\/td> –<\/td><\/tr> 1<\/td> igual a 2 e soma<\/td> 2<\/td><\/tr> 0<\/td> igual a 1 mas n\u00e3o soma por ser zero<\/td> –<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n32 + 16 + 2 = 50<\/strong><\/p>\n\n\n\nVoltando ao assunto, ao inv\u00e9s trabalhar com o n\u00famero em seu formato que j\u00e1 conhecemos, operadores bit a bit trabalham com n\u00fameros em formato bin\u00e1rio. Os inteiros s\u00e3o \u00a0tratados como uma sequ\u00eancia de bits.<\/p>\n\n\n\nOperador<\/th> Nome<\/th> Exemplo<\/th><\/tr> &<\/td> AND<\/td> a & b<\/td><\/tr> |<\/td> OR<\/td> a | b<\/td><\/tr> ^<\/td> XOR<\/td> a ^ b<\/td><\/tr> ~<\/td> NOT<\/td> ~a<\/td><\/tr> <<<\/td> Zero fill left shift<\/td> a << 3<\/td><\/tr> >><\/td> Signed right shift<\/td> a >> 3<\/td><\/tr><\/tbody><\/table>Operadores bit a bit em Python<\/figcaption><\/figure>\n\n\n\nExplicando sobre esses operadores bit a bit ou chamados de bitwise<\/strong>,<\/p>\n\n\n\n\n“&” (AND bit a bit): Retorna um n\u00famero que representa os bits que est\u00e3o definidos tanto no primeiro quanto no segundo n\u00famero.<\/li>\n\n\n\n “|” (OR bit a bit): Retorna um n\u00famero que representa os bits que est\u00e3o definidos no primeiro n\u00famero ou no segundo n\u00famero, ou em ambos.<\/li>\n\n\n\n “^” (XOR bit a bit): Retorna um n\u00famero que representa os bits que est\u00e3o definidos apenas no primeiro n\u00famero ou apenas no segundo n\u00famero, mas n\u00e3o em ambos.<\/li>\n\n\n\n “~” (NOT bit a bit): Inverte todos os bits de um n\u00famero, transformando 0 em 1 e 1 em 0.<\/li>\n\n\n\n “<<” (Deslocamento \u00e0 esquerda): Desloca os bits de um n\u00famero para a esquerda, adicionando zeros \u00e0 direita.<\/li>\n\n\n\n “>>” (Deslocamento \u00e0 direita): Desloca os bits de um n\u00famero para a direita, removendo os bits \u00e0 direita.<\/li>\n<\/ul>\n\n\n\nVoc\u00ea pode converter um n\u00famero decimal em bin\u00e1rio da seguinte usando bin()<\/mark>, como em:<\/strong><\/p>\n\n\n\n>>> bin(5)\n'0b101'\n>>> bin(3)\n'0b11'\n<\/pre>\n\n\n\nPodemos ver que o bin\u00e1rio do decimal 5 \u00e9 101 e de 3 \u00e9 11. <\/p>\n\n\n\n
Veja exemplos de opera\u00e7\u00f5es bit a bit em python com explica\u00e7\u00e3o<\/strong>, <\/p>\n\n\n\n\nOperador AND (&):<\/li>\n<\/ol>\n\n\n\n\n5 & 3 = 1\n\nO operador AND compara cada bit dos n\u00fameros e retorna 1 apenas quando ambos os bits s\u00e3o 1. No caso, o bit mais \u00e0 direita \u00e9 o \u00fanico bit em comum entre 5 (101<\/strong> em bin\u00e1rio) e 3 (011<\/strong> em bin\u00e1rio), resultando em 1 (001 em bin\u00e1rio).<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n\nOperador OR (|):<\/li>\n<\/ol>\n\n\n\n\n5 | 3 = 7\n\nO operador OR compara cada bit dos n\u00fameros e retorna 1 quando pelo menos um dos bits \u00e9 1. No caso, os bits mais \u00e0 direita s\u00e3o iguais a 1 tanto em 5 (101 em bin\u00e1rio) quanto em 3 (011 em bin\u00e1rio), resultando em 7 (111 em bin\u00e1rio).<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n\nOperador XOR (^):<\/li>\n<\/ol>\n\n\n\n\n5 ^ 3 = 6\n\nO operador XOR compara cada bit dos n\u00fameros e retorna 1 apenas quando os bits s\u00e3o diferentes. No caso, os bits mais \u00e0 direita s\u00e3o diferentes entre 5 (101 em bin\u00e1rio) e 3 (011 em bin\u00e1rio), resultando em 6 (110 em bin\u00e1rio).<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n\nDeslocamento para a esquerda (<<):<\/li>\n<\/ol>\n\n\n\n\n5 << 2 = 20\n\n\n\nO deslocamento para a esquerda move todos os bits de um n\u00famero para a esquerda, adicionando zeros \u00e0 direita. No caso, deslocar o n\u00famero bin\u00e1rio de 5 (101) duas posi\u00e7\u00f5es para a esquerda resulta em 20 (10100).<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n\nDeslocamento para a direita (>>):<\/li>\n<\/ol>\n\n\n\n\n5 >> 2 = 1\n\nO deslocamento para a direita move todos os bits de um n\u00famero para a direita, preenchendo os bits \u00e0 esquerda com zeros. No caso, deslocar o n\u00famero bin\u00e1rio de 5 (101) duas posi\u00e7\u00f5es para a direita resulta em 1 (001).<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\nFalando um pouco sobre o operador bitwise NOT<\/strong> ou ~<\/strong><\/p>\n\n\n\nO operador ~<\/strong> inverte cada bit para que 1 seja substitu\u00eddo por 0 e 0 por 1 e retorne o complemento do n\u00famero original.<\/p>\n\n\n\n\u00c9 bom sempre trabalharmos em 8 bits, por exemplo, o n\u00famero 2 \u00e9 10<\/strong> em bin\u00e1rio, mas aqui podemos acrescentar 6 zeros \u00e0 esquerda para formar uma representa\u00e7\u00e3o de 8 bits: 00000010<\/strong>.<\/p>\n\n\n\nMas, como funciona o bitwise NOT em Python? Python utiliza um m\u00e9todo chamado complemento de 2<\/strong> para representar n\u00fameros inteiros. Esse m\u00e9todo \u00e9 uma maneira de representar n\u00fameros negativos em bin\u00e1rio. <\/p>\n\n\n\n\n
![\"Literais](\"https:\/\/categoriaoutros.com.br\/wp-content\/uploads\/2023\/10\/programacao.jpeg\")