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

Existe um benefício em usar um sobre o outro? No Python 2, ambos parecem retornar os mesmos resultados:

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

No Python 3.x, 5 / 2retornará 2.5e 5 // 2retornará 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 // 2retornará, 2.0já 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

Esclarecimento sobre o Python 2.x:

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.0dará 0.5, mas ambos 1/2, 1//2e 1.0//2.0dará 0.

Consulte https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator para obter detalhes

/ -> 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

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:

• Ativo __future__Importação ou não (módulo local)
• Opção de linha de comando Python, -Q oldou-Q new

>>> print 5.0 / 2
2.5

>>> print 5.0 // 2
2.0

Python 2.7 e outra versão futura do python:

• Divisão ( /)

Divide o operando da mão esquerda pelo operando da mão direita

Exemplo: 4 / 2 = 2

• Divisão de Chão ( //)

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 = 4e 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".

A resposta da equação é arredondada para o próximo inteiro menor ou flutuante 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

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//2resulta em 2.0, e não 2porque 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.
• E o outro /é 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