Qual è la differenza tra '/' e '//' quando usato per la divisione?

C'è un vantaggio nell'usare l'uno rispetto all'altro? In Python 2, entrambi sembrano restituire gli stessi risultati:

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

In Python 3.x, 5 / 2tornerà 2.5e 5 // 2tornerà 2. Il primo è la divisione in virgola mobile e il secondo è la divisione del pavimento , a volte anche chiamata divisione intera .

In Python 2.2 o versioni successive nella riga 2.x, non vi è alcuna differenza per gli interi a meno che non si esegua a from __future__ import division, il che fa sì che Python 2.x adotti il ​​comportamento 3.x.

Indipendentemente dalla futura importazione, 5.0 // 2tornerà 2.0poiché questo è il risultato della divisione del piano dell'operazione.

Puoi trovare una descrizione dettagliata su https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator

Chiarimento su Python 2.x:

Chiarire per la linea Python 2.x, /non è né divisione del pavimento né vera divisione. La risposta attualmente accettata non è chiara su questo.

/è la divisione del piano quando lo sono entrambi gli arg int, ma è la vera divisione quando uno o entrambi gli arg sono float.

Quanto sopra dice più verità ed è più chiaro del secondo paragrafo nella risposta accettata.

//implementa la "divisione del pavimento", indipendentemente dal tipo. Così 1.0/2.0darà 0.5, ma entrambi 1/2, 1//2e 1.0//2.0darà 0.

Vedi https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator per i dettagli

/ -> Divisione in virgola mobile

// -> Divisione del pavimento

Vediamo alcuni esempi sia in Python 2.7 che in 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

Ora se vuoi avere (in python 2.7) lo stesso output di python 3.5, puoi fare quanto segue:

Python 2.7.10

from __future__ import division
print (2/3)  ----> 0.6666666666666666   #Python 2.7
print (4/2)  ----> 2.0                  #Python 2.7

Dove non c'è differenza tra la divisione Floor sia in Python 2.7 che in 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

Come tutti hanno già risposto, //è divisione del pavimento.

Perché questo è importante è la //divisione dei piani inequivocabile, in tutte le versioni di Python dalla 2.2, comprese le versioni di Python 3.x.

Il comportamento di /può cambiare in base a:

• __future__Importazione attiva o meno (modulo locale)
• Opzione della riga di comando di Python, o -Q oldo-Q new

>>> print 5.0 / 2
2.5

>>> print 5.0 // 2
2.0

Python 2.7 e altre versioni imminenti di python:

• Division ( /)

Divide l'operando della mano sinistra per l'operando della mano destra

Esempio: 4 / 2 = 2

• Floor Division ( //)

La divisione degli operandi in cui il risultato è il quoziente in cui vengono rimosse le cifre dopo il punto decimale. Ma se uno degli operandi è negativo, il risultato viene pavimentato, ovvero arrotondato da zero (verso l'infinito negativo):

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

Sia /Division e //pavimento operatore di divisione stanno operando in modo simile.

La doppia barra //, è la divisione del pavimento:

>>> 7//3
2

//è la divisione del piano, ti darà sempre il numero intero del risultato. L'altra è la divisione "regolare".

La risposta dell'equazione viene arrotondata al numero intero più piccolo successivo o float con .0 come punto decimale.

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

Le risposte sopra sono buone. Voglio aggiungere un altro punto. Fino ad alcuni valori entrambi generano lo stesso quoziente. Dopo che l'operatore di divisione del piano ( //) funziona bene ma non l' /operatore di divisione ( ).

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

5.0//2risulta 2.0, e non 2perché il tipo restituito dal valore restituito //dall'operatore segue le regole di coercizione di pitone (tipo casting).

Python promuove la conversione del tipo di dati inferiore (intero) in un tipo di dati superiore (float) per evitare la perdita di dati.

• // è la divisione del pavimento, ti darà sempre il valore del pavimento del risultato.
• E l'altro /è la divisione in virgola mobile.

I seguenti sono la differenza tra /e //; Ho eseguito queste operazioni aritmetiche in 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