Operadores e Expressões

A maioria das declarações (linhas lógicas) que você escreve conterão expressões. Um exemplo simples de uma expressão é 2 3. Uma expressão pode ser dividida em operadores e operandos.

Operadores são funcionalidades que fazem algo e podem ser representadas por símbolos como ou por palavras-chave especiais. Os operadores exigem alguns dados para operar e esses dados são chamados operandos. Neste caso, 2 e 3 são os operandos.

Operadores

Vamos examinar brevemente os operadores e seu uso..

Observe que você pode avaliar as expressões dadas nos exemplos usando o intérprete de forma interativa. Por exemplo, para testar a expressão 2 3, use o prompt interativo do interpretador Python:

>>> 2  3
5
>>> 3 * 5
15
>>>

Aqui está uma visão geral rápida dos operadores disponíveis:

  • (mais)

    • Adiciona dois objetos
    • 3 5 gives 8. 'a' 'b' gives 'ab'.
  • - (menos)

    • Dá a subtração de um número do outro; Se o primeiro operando estiver ausente, é assumido como zero.
    • -5.2 gives a negative number and 50 - 24 gives 26.
  • * (multiplicar)

    • Dá a multiplicação dos dois números ou retorna a string repetida várias vezes.
    • 2 * 3 gives 6. 'la' * 3 gives 'lalala'.
  • ** (poder)

    • Retorna x ao poder de y
    • 3 ** 4 gives 81 (ou seja, 3 * 3 * 3 * 3)
  • / (dividir)

    • Divida x por y
    • 13 / 3 gives 4.333333333333333
  • // (dividir e andar)

    • Divida x por y e arredonde a resposta até o valor inteiro mais próximo. Observe que, se um dos valores for um flutuador, você retornará um flutuador.
    • 13 // 3 gives 4
    • -13 // 3 gives -5
    • 9//1.81 gives 4.0
  • % (modulo)

    • Retorna o restante da divisão
    • 13 % 3 gives 1. -25.5 % 2.25 gives 1.5.
  • << (left shift)

    • Desloca os bits do número para a esquerda pelo número de bits especificado. (Cada número é representado na memória por bits ou dígitos binários, isto é, 0 e 1)
    • 2 << 2 gives 8. 2 is represented by 10 in bits.
    • O deslocamento da esquerda em 2 bits dá 1000 que representa a decimal 8.
  • >> (deslocamento para a direita)

    • Desloca os bits do número para a direita pelo número de bits especificado.
    • 11 >> 1 gives 5.
    • 11 is represented in bits by 1011 which when right shifted by 1 bit gives 101which is the decimal 5.
  • & (bit-wise AND)

    • Bitwise AND dos números
    • 5 & 3 gives 1.
  • | (bit-wise OR)

    • OR Bitwise dos números
    • 5 | 3 gives 7
  • ^ (bit-wise XOR)

    • XOR Bitwise dos números
    • 5 ^ 3 gives 6
  • ~ (bit-wise invert)

  • < (menos que)

    • Retorna se x é menor do que y. Todos os operadores de comparação retornam True ou False. Observe a capitalização desses nomes.
    • 5 < 3 gives False and 3 < 5 gives True.
    • As comparações podem ser encadeadas arbitrariamente: 3 < 5 < 7 gives True.
  • > (Melhor que)

    • Retorna se x é maior do que y
    • 5 > 3 retorna a True. Se ambos os operandos são números, eles são convertidos primeiro para um tipo comum. Caso contrário, sempre retorna False.
  • <= (menos que ou igual a)

    • Retorna se x é menor ou igual a y
    • x = 3; y = 6; x <= y retorna a True
  • >= (melhor que ou igual a)

    • Retorna se x é maior ou igual a y
    • x = 4; y = 3; x >= 3 retorna a True
  • == (igual a)

    • Compara se os objetos são iguais
    • x = 2; y = 2; x == y retorna a True
    • x = 'str'; y = 'stR'; x == y retorna a False
    • x = 'str'; y = 'str'; x == y retorna a True
  • != (não igual a)

    • Compara se os objetos não são iguais
    • x = 2; y = 3; x != y retorna a True
  • not (booleano NOT)

    • Se x for True, retorna a False. Se x for False, ele retorna um True.
    • x = True; not x retorna a False.
  • and (boolean AND)

    • x and y retorna a False se x for False, senão retorna uma avaliação de y
    • x = False; y = True; x and y retorna a False já que x é False. Nesse caso, Python não avaliará y já que sabe que o lado esquerdo da expressão 'e' é False o que implica que toda a expressão será False independentemente dos outros valores. Isso é chamado de avaliação de curto-circuito.
  • or (boolean OR)

    • Se x for True, ele retorna um Verdadeiro, senão ele retorna uma avaliação de y
    • x = True; y = False; x or y retorna a True. A avaliação de curto-circuito também se aplica aqui.

Atalho para operação e atribuição matemática

É comum executar uma operação matemática em uma variável e, em seguida, atribuir o resultado da operação de volta para a variável, portanto, há um atalho para tais expressões:

a = 2
a = a * 3

pode ser descrito como:

a = 2
a *= 3

Perceba que var = var operation expression se torna var operation= expression.

Ordem de avaliação

Se você tivesse uma expressão como 2 3 * 4, A adição é feita primeiro ou a multiplicação? Nossas matemáticas do ensino médio nos dizem que a multiplicação deve ser feita primeiro. Isso significa que o operador de multiplicação tem maior precedência do que o operador de adição.

A tabela a seguir fornece a tabela de precedência para Python, desde a menor precedência (menos vinculativa) até a maior precedência (mais vinculativa). Isso significa que, em uma determinada expressão, o Python avaliará primeiro os operadores e as expressões mais baixas na tabela antes das que estão listadas acima na tabela.

A tabela a seguir, retirada da Manual de referência de Python, é fornecido por uma questão de exaustividade. É muito melhor usar parênteses para agrupar operadores e operandos adequadamente para especificar explicitamente a precedência. Isso torna o programa mais legível. Vejo Alterando a Ordem de Avaliação abaixo para detalhes.

  • lambda : Lambda Expression
  • if - else : Conditional expression
  • or : Boolean OR
  • and : Boolean AND
  • not x : Boolean NOT
  • in, not in, is, is not, <, <=, >, >=, !=, == : Comparisons, including membership tests and identity tests
  • | : Bitwise OR
  • ^ : Bitwise XOR
  • & : Bitwise AND
  • <<, >> : Shifts
  • , - : Addition and subtraction
  • *, /, //, % : Multiplication, Division, Floor Division and Remainder
  • x, -x, ~x : Positive, Negative, bitwise NOT
  • ** : Exponentiation
  • x[index], x[index:index], x(arguments...), x.attribute : Subscrição, corte, chamada, referência de atributo
  • (expressions...), [expressions...], {key: value...}, {expressions...} : Visualização de ligação ou tupla, exibição de lista, exibição de dicionário, configuração de exibição

Os operadores que ainda não conhecemos serão explicados em capítulos posteriores.

Operadores com a mesmo precedência estão listados na mesma linha na tabela acima. Por exemplo, e - tem o mesmo precedente.

Alterando a ordem da avaliação

Para tornar as expressões mais legíveis, podemos usar parênteses. Por exemplo, 2 (3 * 4) é definitivamente mais fácil de entender do que 2 3 * 4 que requer conhecimento das precedências do operador. Como com tudo o resto, os parênteses devem ser usados com razoavelmente (não exagere) e não devem ser redundantes, como em (2 (3 * 4)).

Existe uma vantagem adicional em usar parênteses - isso nos ajuda a mudar a ordem de avaliação. Por exemplo, se você deseja que a adição seja avaliada antes da multiplicação em uma expressão, então você pode escrever algo como (2 3) * 4.

Associatividade

Os operadores geralmente são associados da esquerda para a direita. Isso significa que os operadores com o mesmo precedente são avaliados de uma maneira direta para a esquerda. Por exemplo, 2 3 4 é avaliado como (2 3) 4.

Expressões

Exemplo (salvar como expression.py):

length = 5
breadth = 2

area = length * breadth
print('Area is', area)
print('Perimeter is', 2 * (length  breadth))

Output:

$ python expression.py
Area is 10
Perimeter is 14

Como funciona

O comprimento e largura do retângulo são armazenados em variáveis com o mesmo nome. Usamos estes para calcular a área e o perímetro do retângulo com a ajuda de expressões. Nós armazenamos o resultado da expressão length * breadth na variável area e depois imprima usando o print função. No segundo caso, usamos diretamente o valor da expressão 2 * (length breadth) na função de impressão.

Além disso, observe como Python belas impressões a saída. Embora não tenhamos especificado um espaço entre 'Area is' e a variável area, Python coloca para nós para que possamos obter um bom resultado limpo e o programa é muito mais legível dessa maneira (já que não precisamos nos preocupar com o espaçamento nas cordas que usamos para a saída). Este é um exemplo de como o Python facilita a vida para o programador.

Resumo

Nós vimos como usar operadores, operandos e expressões - estes são os blocos de construção básicos de qualquer programa. Em seguida, veremos como fazer uso destes em nossos programas usando declarações.