Я видел это в чьем-то коде:
y = img_index // num_images
где img_index - текущий индекс, а num_images - 3.
Когда я возился с // в IPython, кажется, что он действует как знак деления (т. Е. Один косая черта). Мне просто интересно, есть ли причина для двойных косых черт?
В Python 3 они заставили оператор / выполнять деление с плавающей запятой и добавили оператор // для целочисленного деления (т.е. частное без остатка); тогда как в Python 2 оператор / был просто целочисленным делением, если только один из операндов уже не был числом с плавающей запятой.
В Python 2.X:
>>> 10/3
3
>>> # To get a floating point number from integer division:
>>> 10.0/3
3.3333333333333335
>>> float(10)/3
3.3333333333333335
В Python 3:
>>> 10/3
3.3333333333333335
>>> 10//3
3
Для получения дополнительной информации см. PEP238.
/ против \ ... но я никогда не мог вспомнить, какой из них был!
- person Matthew Scharley; 08.10.2009
\ как оператор.
- person Mark Rushakoff; 08.10.2009
int(n/i). Отличная информация здесь!
- person Hidde; 20.08.2012
// - безусловно, разделение полов, например:
>>> 4.0//1.5
2.0
Как видите, даже несмотря на то, что оба операнда floats, // все еще этажи - так что вы всегда надежно знаете, что он собирается делать.
Одиночный / может или не может быть перекрытым, в зависимости от выпуска Python, будущего импорта и даже флагов, на которых запускается Python, например:
$ python2.6 -Qold -c 'print 2/3'
0
$ python2.6 -Qnew -c 'print 2/3'
0.666666666667
Как видите, single / может возвращать значение с плавающей запятой, или оно может возвращать значение с плавающей запятой, исходя из совершенно нелокальных проблем, вплоть до значения флага -Q ... ;-).
Итак, если и когда вы знаете, что хотите пол, всегда используйте //, который гарантирует это. Если и когда вы знаете, что не хотите пол, поставьте float() вокруг другого операнда и используйте /. Любая другая комбинация, и вы зависите от версии, импорта и флагов! -)
type(2//3) в Python 3.8.6 возвращает мне <class 'int'>.
- person Mark Ransom; 18.06.2021
В дополнение к этим другим ответам оператор // также предлагает значительные (3x) преимущества в производительности по сравнению с /, если предполагается, что вам нужно целочисленное деление.
$ python -m timeit '20.5 // 2'
100,000,000 loops, best of 3: 14.9 nsec per loop
$ python -m timeit '20.5 / 2'
10,000,000 loops, best of 3: 48.4 nsec per loop
$ python -m timeit '20 / 2'
10,000,000 loops, best of 3: 43.0 nsec per loop
$ python -m timeit '20 // 2'
100,000,000 loops, best of 3: 14.4 nsec per loop
//.
- person Peter Mortensen; 01.12.2020
Чтобы дополнить ответ Алекса, я бы добавил что, начиная с Python 2.2.0a2, from __future__ import division является удобной альтернативой использованию большого количества float(…)/…. Все деления выполняют деления float, кроме тех, у которых есть //. Это работает со всеми версиями, начиная с 2.2.0a2.
// можно рассматривать как псевдоним math.floor () для подразделений с возвращаемым значением типа float. Он работает как no-op для подразделений с возвращаемым значением типа int.
import math
# let's examine `float` returns
# -------------------------------------
# divide
>>> 1.0 / 2
0.5
# divide and round down
>>> math.floor(1.0/2)
0.0
# divide and round down
>>> 1.0 // 2
0.0
# now let's examine `integer` returns
# -------------------------------------
>>> 1/2
0
>>> 1//2
0
