O que significam estes operadores(**, ^, %, //)? [fechado]

que não a norma +, -, *e / operadores; mas o que significa isto? (** , ^ , %, //) ?

>>> 9+float(2) # addition
11.0
>>> 9-float(2) # subtraction
7.0
>>> 9*float(2) # multiplication
18.0
>>> 9/float(2) # division
4.5
>>>
>>> 9**float(2) # This looks like a square, (i.e. power 2) 
81.0
>>> 9**float(3) # So ** is equivalent to `math.pow(x,p)` ?
729.0

e o operador?

>>> 9^int(2) # What is `^` in `x^u` , it only allows `int` for `u`
11
>>> 9^int(3)
10
>>> 9^int(4)
13
>>> 9^int(5)
12
>>> 9^int(6)
15
>>> 9^int(7)
14
>>> 9^int(8)
1
>>> 9^int(9)
0
>>> 9^int(10)
3
>>> 9^int(11)
2
>>> 9^int(12)
5

% em x%m devolve um módulo de resto normal, mas só se m < x, porque é que isso acontece? O que faz?

>>> 9%float(2)
1.0
>>> 9%float(3)
0.0
>>> 9%float(4)
1.0
>>> 9%float(5)
4.0
>>> 9%float(6)
3.0
>>> 9%float(7)
2.0
>>> 9%float(8)
1.0
>>> 9%float(9)
0.0
>>> 9%float(10)
9.0
>>> 9%float(11)
9.0
>>> 9%float(12)
9.0

e o operador? o que faz?

>>> 9//float(2)
4.0
>>> 9//float(3)
3.0
>>> 9//float(4)
2.0
>>> 9//float(5)
1.0
>>> 9//float(6)
1.0
>>> 9//float(7)
1.0
>>> 9//float(8)
1.0
>>> 9//float(9)
1.0
>>> 9//float(1)
9.0
>>> 9//float(0.5)
18.0
Author: coldspeed, 2013-03-04
Source

3 answers

  • **: exponenciação
  • ^: exclusivo-ou (bitwise)
  • %: Módulo
  • //: dividir com resultado integral (eliminar o resto)
 68
Author: John Zwinck, 2013-03-04 03:07:35

Você pode encontrar todos esses operadores na referência da linguagem Python , embora você tenha que percorrer um pouco para encontrá-los todos. Como outras respostas disseram:

  • o operador ** faz exponenciação. a ** b é a elevado ao poder b. O mesmo símbolo ** também é usado em argumentos de função e invocações, com um significado diferente (passando e recebendo argumentos de palavras-chave arbitrários).
  • o operador ^ faz um xor binário. a ^ b irá devolver um valor com apenas os bits definidos em a ou em b, mas não em ambos. Este é simples!
  • o operador % é principalmente para encontrar o módulo de dois inteiros. a % b devolve o restante após ter dividido a por b. Ao contrário dos operadores de módulo em algumas outras linguagens de programação( como C), em Python um módulo terá o mesmo sinal que b, ao invés do mesmo sinal que a. O mesmo operador também é usado para o estilo "velho" de formatação de texto, então a % b pode devolve um texto se a for um texto de formato e b for um valor (ou uma tupla de valores) que pode ser inserido em a.
  • o operador // faz a versão do Python da divisão inteira. A divisão inteira de Python não é exatamente a mesma que a divisão inteira oferecida por algumas outras linguagens (como C), uma vez que gira em direção ao infinito negativo, ao invés de em direção ao zero. Juntamente com o operador de módulo, pode dizer-se que sim. No Python 2, a divisão do chão é o comportamento padrão quando você divide dois inteiros (usando o operador de divisão normal /). Uma vez que isso pode ser inesperado (especialmente quando você não é exigente sobre que tipos de números você recebe como argumentos para uma função), o Python 3 mudou para fazer a divisão "true" (ponto flutuante) a norma para a divisão que seria arredondada de outra forma, e ele fará a divisão "floor" apenas quando explicitamente solicitado. (Você também pode obter o novo comportamento no Python 2 colocando from __future__ import division no topo de seus arquivos. Recomendo vivamente aquilo!)
 18
Author: Blckknght, 2013-03-04 14:24:57

Está correcto que ** é a função de poder.

^ é bitwise XOR.

% é realmente a operação de Módulo, mas note que para números positivos, x % m = x sempre que m > x. Isto decorre da definição de Módulo. (Adicionalmente, Python especifica x % m para ter o sinal de m.)

// é uma operação de divisão que retorna um inteiro descartando o restante. Este é o formulário padrão de divisão usando o / na maior parte da programação idioma. No entanto, o Python 3 mudou o comportamento de / para executar a divisão de ponto flutuante mesmo que os argumentos sejam inteiros . O operador // foi introduzido em python 2.6 e Python 3 para fornecer um operador de divisão inteira que se comportaria consistentemente entre Python 2 e Python 3. Isto significa: 

| context                                | `/` behavior   | `//` behavior |
---------------------------------------------------------------------------
| floating-point arguments, Python 2 & 3 | float division | int divison   |
---------------------------------------------------------------------------
| integer arguments, python 2            | int division   | int division  |
---------------------------------------------------------------------------
| integer arguments, python 3            | float division | int division  |

Para mais detalhes, veja esta pergunta: divisão em Python 2.7. e 3.3

 3
Author: Kyle Strand, 2017-11-14 23:39:58