328 lines
7.0 KiB
Markdown
328 lines
7.0 KiB
Markdown
---
|
||
title: Basic Operators
|
||
localeTitle: Operadores Básicos
|
||
---
|
||
## Operadores Básicos
|
||
|
||
Operadores são símbolos que dizem ao interpretador para fazer uma operação específica (viz, aritmética, comparação, lógica, etc.)
|
||
|
||
Os diferentes tipos de operadores em Python estão listados abaixo:
|
||
|
||
1. Operadores aritméticos
|
||
2. Operadores Relacionais
|
||
3. Operadores bit a bit
|
||
4. Operadores de atribuição
|
||
5. Operadores lógicos
|
||
6. Operadores de Associação
|
||
7. Operadores de Identidade
|
||
|
||
#### Operadores aritméticos
|
||
|
||
Um operador aritmético usa dois operandos como entrada, executa um cálculo e retorna o resultado.
|
||
|
||
Considere a expressão **"a = 2 + 3"** . Aqui, `2` e `3` são os _operandos_ e `+` é o _operador aritmético_ . O resultado da operação é armazenado na variável a.
|
||
|
||
Operador
|
||
|
||
Descrição
|
||
|
||
Uso
|
||
|
||
+
|
||
|
||
Executa Adição nos operandos
|
||
|
||
12 + 3 = 15
|
||
|
||
\-
|
||
|
||
Executa subtração nos operandos. Subtrai o operando direito do operando esquerdo
|
||
|
||
12 - 3 = 9
|
||
|
||
\*
|
||
|
||
Executa a multiplicação nos operandos
|
||
|
||
12 \* 3 = 36
|
||
|
||
/
|
||
|
||
Executa a divisão nos operandos. Divide o operando esquerdo pelo operando direito
|
||
|
||
12/3 = 4
|
||
|
||
Nota: Quando dois inteiros são usados, o resultado difere entre o Python 2 e o Python 3.
|
||
|
||
5/2 = 2 no Python 2
|
||
|
||
5/2 = 2,5 no Python 3
|
||
|
||
%
|
||
|
||
Executa um Modulo nos operandos. Retorna o restante obtido ao dividir o operando esquerdo pelo operando direito
|
||
|
||
16% 3 = 1
|
||
|
||
\*\*
|
||
|
||
Executa uma operação de exponenciação. O operando da esquerda é elevado à potência do operando da direita
|
||
|
||
12 \*\* 3 = 1728
|
||
|
||
//
|
||
|
||
Executa uma operação de divisão de piso. Retorna a parte integral do quociente obtido após o mergulho do operando esquerdo pelo operando direito
|
||
|
||
18 // 5 = 3
|
||
|
||
Nota: Para obter o resultado no tipo flutuante, um dos operandos também deve ser do tipo flutuante.
|
||
|
||
#### Operadores Relacionais
|
||
|
||
Um operador relacional é usado para comparar dois operandos para decidir uma relação entre eles. Ele retorna um valor booleano com base na condição.
|
||
|
||
Operador
|
||
|
||
Descrição
|
||
|
||
Uso
|
||
|
||
\>
|
||
|
||
Retorna True se o operando da esquerda for maior que o operando da direita Retorna Falso de outra forma
|
||
|
||
12> 3 devolve Verdadeiro
|
||
|
||
<
|
||
|
||
Retorna Verdadeiro se o operando direito for maior que o operando esquerdo Retorna Falso de outra forma
|
||
|
||
12 <3 retorna falso
|
||
|
||
\==
|
||
|
||
Retorna True se ambos os operandos são iguais Retorna Falso de outra forma
|
||
|
||
12 = = 3 retorna falso
|
||
|
||
\> =
|
||
|
||
Retorna Verdadeiro se o operando da esquerda for maior ou igual ao operando da direita Retorna Falso de outra forma
|
||
|
||
12> = 3 devolve Verdadeiro
|
||
|
||
<=
|
||
|
||
Retorna True se o operando da direita for maior ou igual ao operando da esquerda Retorna Falso de outra forma
|
||
|
||
12 <= 3 retorna falso
|
||
|
||
! =
|
||
|
||
Retorna True se ambos os operandos não forem iguais Retorna Falso de outra forma
|
||
|
||
12! = 3 devolve Verdadeiro
|
||
|
||
#### Operadores bit a bit
|
||
|
||
Um operador bit a bit executa operações nos operandos pouco a pouco
|
||
|
||
Considere a = 2 (em notação binária, 10) eb = 3 (em notação binária, 11) para os usos abaixo
|
||
|
||
Operador
|
||
|
||
Descrição
|
||
|
||
Uso
|
||
|
||
E
|
||
|
||
Executa operação bit a bit AND nos operandos
|
||
|
||
a & b = 2 Binário: 10 e 11 = 10
|
||
|
||
|
|
||
|
||
Executa operação OR bit a bit nos operandos
|
||
|
||
a | b = 3 Binário: 10 | 11 = 11
|
||
|
||
^
|
||
|
||
Executa a operação XOR bit a bit nos operandos
|
||
|
||
a ^ b = 1 Binário: 10 ^ 11 = 01
|
||
|
||
~
|
||
|
||
Executa operação NOT bit a bit no operando Vira cada bit no operando
|
||
|
||
~ a = -3 Binário: ~ (00000010) = (11111101)
|
||
|
||
\>>
|
||
|
||
Executa um deslocamento à direita bit a bit. Desloca os bits do operando esquerdo, diretamente pelo número de bits especificado como operando à direita
|
||
|
||
a >> b = 0 Binário: 00000010 >> 00000011 = 0
|
||
|
||
<< <<
|
||
|
||
Executa um deslocamento à esquerda bit a bit. Desloca os bits do operando esquerdo, deixados pelo número de bits especificado como operando à direita
|
||
|
||
a << b = 16 Binário: 00000010 << 00000011 = 00001000
|
||
|
||
#### Operadores de atribuição
|
||
|
||
Um operador de atribuição é usado para atribuir valores a uma variável. Isso geralmente é combinado com outros operadores (como aritmética, bit a bit) onde a operação é executada nos operandos e o resultado é atribuído ao operando esquerdo.
|
||
|
||
Considere os seguintes exemplos, **a = 18** Aqui `=` é um operador de atribuição e o resultado é armazenado na variável a. **a + = 10** . Aqui `+=` é um operador de atribuição e o resultado é armazenado na variável a. Isso é o mesmo que a = a + 10.
|
||
|
||
Operador
|
||
|
||
Uso
|
||
|
||
\=
|
||
|
||
a = 5. O valor 5 é atribuído à variável a
|
||
|
||
\+ =
|
||
|
||
a + = 5 é equivalente a = a + 5
|
||
|
||
\- =
|
||
|
||
a - = 5 é equivalente a = a - 5
|
||
|
||
\* =
|
||
|
||
a \* = 3 é equivalente a = a \* 3
|
||
|
||
/ =
|
||
|
||
a / = 3 é equivalente a = a / 3
|
||
|
||
% =
|
||
|
||
um% = 3 é equivalente a = a% 3
|
||
|
||
\*\* =
|
||
|
||
a \*\* = 3 é equivalente a = a \*\* 3
|
||
|
||
// =
|
||
|
||
a // = 3 é equivalente a = a // 3
|
||
|
||
& =
|
||
|
||
a & = 3 é equivalente a = a & 3
|
||
|
||
| =
|
||
|
||
a | = 3 é equivalente a = a | 3
|
||
|
||
^ =
|
||
|
||
a ^ = 3 é equivalente a = a ^ 3
|
||
|
||
\>> =
|
||
|
||
a >> = 3 é equivalente a = a >> 3
|
||
|
||
<< =
|
||
|
||
a << = 3 é equivalente a = a << 3
|
||
|
||
#### Operadores lógicos
|
||
|
||
Um operador lógico é usado para tomar uma decisão com base em várias condições. Os operadores lógicos usados no Python são `and` , `or` e `not`
|
||
|
||
Operador
|
||
|
||
Descrição
|
||
|
||
Uso
|
||
|
||
e
|
||
|
||
Retorna True se ambos os operandos forem True Retorna Falso de outra forma
|
||
|
||
aeb
|
||
|
||
ou
|
||
|
||
Retorna True se qualquer um dos operandos for True Retorna Falso de outra forma
|
||
|
||
a ou B
|
||
|
||
não
|
||
|
||
Retorna Verdadeiro se o operando for Falso Retorna Falso de outra forma
|
||
|
||
não é um
|
||
|
||
#### Operadores de Associação
|
||
|
||
Um operador de associação é usado para identificar a associação em qualquer sequência (listas, cadeias de caracteres, tuplas). `in` e `not in` são operadores de associação
|
||
|
||
`in` retorna True se o valor especificado for encontrado na sequência. Retorna False caso contrário. `not in` retornado True se o valor especificado não for encontrado na seqüência. Retorna False caso contrário.
|
||
|
||
###### Exemplo de uso
|
||
|
||
```py
|
||
a = [1,2,3,4,5]
|
||
|
||
#Is 3 in the list a?
|
||
print 3 in a # prints True
|
||
|
||
#Is 12 not in list a?
|
||
print 12 not in a # prints True
|
||
|
||
str = "Hello World"
|
||
|
||
#Does the string str contain World?
|
||
print "World" in str # prints True
|
||
|
||
#Does the string str contain world? (note: case sensitive)
|
||
print "world" in str # prints False
|
||
|
||
print "code" not in str # prints True
|
||
```
|
||
|
||
#### Operadores de Identidade
|
||
|
||
Um operador de identidade é usado para verificar se duas variáveis compartilham o mesmo local de memória. `is` e `is not` são operadores de identidade
|
||
|
||
`is` retorna true se o operandos se referir ao mesmo objeto. Retorna False caso contrário. `is not` retorna True se os operandos não se referirem ao mesmo objeto. Retorna False caso contrário.
|
||
|
||
Por favor note que dois valores, quando iguais, não implicam que sejam idênticos.
|
||
|
||
###### Exemplo de uso
|
||
|
||
```py
|
||
a = 3
|
||
b = 3
|
||
c = 4
|
||
print a is b # prints True
|
||
print a is not b # prints False
|
||
print a is not c # prints True
|
||
|
||
x = 1
|
||
y = x
|
||
z = y
|
||
print z is 1 # prints True
|
||
print z is x # prints True
|
||
|
||
str1 = "FreeCodeCamp"
|
||
str2 = "FreeCodeCamp"
|
||
|
||
print str1 is str2 # prints True
|
||
print "Code" is str2 # prints False
|
||
|
||
a = [10,20,30]
|
||
b = [10,20,30]
|
||
|
||
print a is b # prints False (since lists are mutable in Python)
|
||
|
||
``` |