Respostas:
No Python 3.x, 5 / 2
retornará 2.5
e 5 // 2
retornará 2
. O primeiro é a divisão de ponto flutuante e o segundo é a divisão de piso , às vezes também chamada de divisão inteira .
No Python 2.2 ou posterior na linha 2.x, não há diferença para números inteiros, a menos que você execute a from __future__ import division
, o que faz com que o Python 2.x adote o comportamento 3.x.
Independentemente da importação futura, 5.0 // 2
retornará, 2.0
já que esse é o resultado da divisão de piso da operação.
Você pode encontrar uma descrição detalhada em https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator
python -Qnew
. outras opções de divisão: -Qold
(padrão), -Qwarn
,-Qwarnall
5.0 / 2
retorna 2.5
em todas as versões, assim como 5 / 2.0
- o antigo comportamento só é diferente quando os dois operandos o são int
.
Esclarecer para a linha Python 2.x, /
não é divisão de piso nem divisão verdadeira. A resposta atual aceita não é clara sobre isso.
/
é a divisão do piso quando os dois argumentos são int
, mas é a verdadeira divisão quando um ou ambos os argumentos sãofloat
.
O exposto acima diz mais verdade e é mais claro que o segundo parágrafo da resposta aceita.
//
implementa "divisão de piso", independentemente do seu tipo. Então
1.0/2.0
dará 0.5
, mas ambos 1/2
, 1//2
e 1.0//2.0
dará 0
.
Consulte https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator para obter detalhes
math.floor()
ou math.fmod()
se não tiver certeza do que está acontecendo com os operadores unários.
/
e //
são operadores binários (dois operandos, esquerda e direita, numerador e denominador)
/ -> Divisão de ponto flutuante
// -> Divisão de pisos
Vamos ver alguns exemplos no python 2.7 e no Python 3.5.
Python 2.7.10 vs. Python 3.5
print (2/3) ----> 0 Python 2.7
print (2/3) ----> 0.6666666666666666 Python 3.5
Python 2.7.10 vs. Python 3.5
print (4/2) ----> 2 Python 2.7
print (4/2) ----> 2.0 Python 3.5
Agora, se você deseja ter (no python 2.7) a mesma saída do python 3.5, você pode fazer o seguinte:
Python 2.7.10
from __future__ import division
print (2/3) ----> 0.6666666666666666 #Python 2.7
print (4/2) ----> 2.0 #Python 2.7
Onde, como não há diferenças entre a divisão Floor no python 2.7 e no python 3.5
138.93//3 ---> 46.0 #Python 2.7
138.93//3 ---> 46.0 #Python 3.5
4//3 ---> 1 #Python 2.7
4//3 ---> 1 #Python 3.5
-100 // 33
=> -4 ; 100 // -33
=> -4 ; mas, devido à direção de arredondamento da função do piso, a próxima pode parecer contra-intuitiva quando comparada à anterior: -100 // -33
=> 3 .
Como todo mundo já respondeu, //
é a divisão do piso.
Por que isso é importante é que //
é uma divisão sem ambiguidade, em todas as versões do Python da 2.2, incluindo as versões do Python 3.x.
O comportamento de /
pode mudar dependendo de:
__future__
Importação ou não (módulo local)-Q old
ou-Q new
>>> print 5.0 / 2
2.5
>>> print 5.0 // 2
2.0
Python 2.7 e outra versão futura do python:
/
)Divide o operando da mão esquerda pelo operando da mão direita
Exemplo: 4 / 2 = 2
//
)A divisão dos operandos em que o resultado é o quociente no qual os dígitos após o ponto decimal são removidos. Mas se um dos operandos for negativo, o resultado será calculado, ou seja, arredondado para longe de zero (em direção ao infinito negativo):
Exemplos: 9//2 = 4
e 9.0//2.0 = 4.0
, -11//3 = -4
,-11.0//3 = -4.0
A /
divisão e o //
operador da divisão de piso estão operando de maneira semelhante.
A barra dupla,, //
é a divisão do piso:
>>> 7//3
2
//
é a divisão do piso, ele sempre fornecerá o piso inteiro do resultado. O outro é a divisão "regular".
As respostas acima são boas. Eu quero adicionar outro ponto. Até alguns valores, ambos resultam no mesmo quociente. Depois desse operador de divisão de andar ( //
), funciona bem, mas não o /
operador de divisão ( ).
- > int(755349677599789174/2)
- > 377674838799894592 #wrong answer
- > 755349677599789174 //2
- > 377674838799894587 #correct answer
5.0//2
resulta em 2.0
, e não 2
porque o tipo de retorno do valor de retorno de//
operador segue as regras de coerção python (conversão de tipo).
O Python promove a conversão do tipo de dados mais baixo (número inteiro) para o tipo de dados mais alto (float) para evitar a perda de dados.
//
é a divisão de piso, sempre fornecerá o valor mínimo do resultado./
é a divisão de ponto flutuante.Seguintes são a diferença entre /
e //
; Eu executei essas operações aritméticas no Python 3.7.2
>>> print (11 / 3)
3.6666666666666665
>>> print (11 // 3)
3
>>> print (11.3 / 3)
3.7666666666666667
>>> print (11.3 // 3)
3.0
//
operador para fazer a divisão inteira.