Qual é a diferença entre '/' e '//', quando utilizado para a divisão?

Question

Existe uma vantagem de usar um sobre o outro? Em Python 2, ambos parecem retornam os mesmos resultados:

>>> 6/3
2
>>> 6//3
2

Answer 1

Em Python 3.0, 5 / 2 voltará 2.5 e 5 // 2 voltará 2. O primeiro é flutuante divisão ponto, eo segundo é a divisão chão, às vezes também chamado inteiro divisão.

Em Python 2.2 ou posterior na linha 2.x, não há diferença para inteiros a menos que você executar uma from __future__ import division, que faz com que Python 2.x para adotar o comportamento de 3.0

Independentemente da futura importação, 5.0 // 2 voltará 2.0 já que é o resultado da divisão andar 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

Answer 2

Ela ajuda a esclarecer para o 2.x linha Python, / não é nem a divisão chão nem verdadeira divisão. A resposta aceita atual não é clara sobre isso. / é a divisão chão quando ambos os argumentos são int, mas é verdade divisão quando um ou ambos os argumentos são float.

O texto acima diz muito mais verdade, e é muito mais clara do que o 2º parágrafo na resposta aceita.

Answer 3

implementa // "divisão chão", independentemente do seu tipo. assim 1.0/2.0 dará 0.5, mas ambos 1/2, 1//2 e 1.0//2.0 dará 0.

https: //docs.python .org / whatsnew / 2.2.html # pep-238 mudando-the-division-operador para mais detalhes

Answer 4

/ -> Floating divisão ponto

// -> divisão Piso

Vamos ver alguns exemplos em ambos pitão 2,7 e 3,5 em Python.

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ê quer ter (em python 2,7) mesma saída como em 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 já que não há differece entre a divisão Pavimento em ambos python 2.7 e em 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

Answer 5

Como todos já respondeu, // é a divisão chão.

Por que isso é importante é que // é a divisão chão de forma inequívoca, em todas as versões do Python de 2,2, incluindo Python 3.x versões.

O comportamento do / pode mudar dependendo de:

• importação __future__ ativa ou não (módulo-local)
• opção de linha de comando Python, quer -Q old ou -Q new

Answer 6

>>> print 5.0 / 2
2.5

>>> print 5.0 // 2
2.0

Answer 7

Python 2.7 e outra próxima versão do python:

• Divisão (/)

Divide deixou operando mão por mão direita operando

Exemplo: 4 / 2 = 2

• Piso Divisão (//)

A divisão de operandos em que o resultado é o quociente em que os algarismos após a casa decimal são removidos. Mas se um dos operandos for negativo, o resultado é pavimentado, ou seja, arredondado longe de zero (para o infinito negativo):

Exemplos: 9//2 = 4 e 9.0//2.0 = 4.0, -11//3 = -4, -11.0//3 = -4.0

Ambos / Divisão e // operador de divisão chão estão operando de maneira semelhante.

Answer 8

A barra dupla, //, é a divisão andar:

>>> 7//3
2

Answer 9

Nesta resposta que não só vai dizer a resposta, mas também os benefícios de //.

A maioria de vocês, que usam Python deve estar sabendo sobre o operador de divisão andar (//) em Python. Para quem não sabe, este operador retorna o valor chão após a divisão. Por Exemplo: 5/2 = 2,5, mas 5 // 2 = 2 (2 é o valor mínimo de 2,5)

Mas os comporta operador de divisão anormalmente geral para números maiores que 10 ^ 17.

x = 10000000000000000000006
if x / 2 == x // 2:
    print("Hello")
else:
    print("World")

Para o código acima, Mundo serão impressos e não Olá. Isso ocorre porque 10000000000000000000006/2 voltará 5e + 21, mas 10000000000000000000006 // 2 retornará a resposta correta 5000000000000000000003. Mesmo int (10000000000000000000006/2) irá retornar 5000000000000000000000, o que é incorreto.

Por isso mesmo que você quer dividir grandes números, o uso // operador.

Por exemplo: Se você quiser encontrar soma das primeiras 100000000000000000000000010002 números, com fórmula: n (n + 1) / 2, o operador de divisão normal (/) vai lhe dar resposta incorreta, mas // operador lhe dará corrigir resposta.

Answer 10

// é a divisão chão, ele vai sempre dar-lhe a palavra inteira do resultado. 'regular' divisão o outro é.

Answer 11

A resposta da equação é arredondado para o próximo número inteiro menor ou flutuador com 0,0 como ponto decimal.

>>>print 5//2
2
>>> print 5.0//2
2.0
>>>print 5//2.0
2.0
>>>print 5.0//2.0
2.0

Answer 12

As respostas acima são boas. Eu quero adicionar outro ponto. Até alguns valores Ambos resultar no mesmo quociente. Depois disso operador de divisão andar (//) funciona bem, mas não divisão operador (/).

 - > int(755349677599789174/2)
 - > 377674838799894592      #wrong answer
 - > 755349677599789174 //2
 - > 377674838799894587      #correct answer

Answer 13

A seguir são a diferença entre '/' e '//'; Tenho executar essas operações aritméticas em 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

Answer 14

Resultados 5.0//2 em 2.0, e não 2 porque o tipo de retorno do valor de retorno do operador // segue coerção python (tipo fundição) regras.

Python promove a conversão do tipo de dados inferior (inteiro) maior para tipo de dados (flutuador) para evitar perda de dados.