it-swarm.com.de

Unterschied zwischen "//" und "/" in Python 2

Python 2 hat zwei Divisionsoperatoren: / und //. Die folgende Ausgabe:

========================================= RESTART: Shell =========================================
>>> for x in range(10):
        for y in range(1, 10):
                print x,'//',y,'=',x//y
                print x,'/',y,'=',x/y
                print


0 // 1 = 0
0 / 1 = 0

0 // 2 = 0
0 / 2 = 0

0 // 3 = 0
0 / 3 = 0

0 // 4 = 0
0 / 4 = 0

0 // 5 = 0
0 / 5 = 0

0 // 6 = 0
0 / 6 = 0

0 // 7 = 0
0 / 7 = 0

0 // 8 = 0
0 / 8 = 0

0 // 9 = 0
0 / 9 = 0

1 // 1 = 1
1 / 1 = 1

1 // 2 = 0
1 / 2 = 0

1 // 3 = 0
1 / 3 = 0

1 // 4 = 0
1 / 4 = 0

1 // 5 = 0
1 / 5 = 0

1 // 6 = 0
1 / 6 = 0

1 // 7 = 0
1 / 7 = 0

1 // 8 = 0
1 / 8 = 0

1 // 9 = 0
1 / 9 = 0

2 // 1 = 2
2 / 1 = 2

2 // 2 = 1
2 / 2 = 1

2 // 3 = 0
2 / 3 = 0

2 // 4 = 0
2 / 4 = 0

2 // 5 = 0
2 / 5 = 0

2 // 6 = 0
2 / 6 = 0

2 // 7 = 0
2 / 7 = 0

2 // 8 = 0
2 / 8 = 0

2 // 9 = 0
2 / 9 = 0

3 // 1 = 3
3 / 1 = 3

3 // 2 = 1
3 / 2 = 1

3 // 3 = 1
3 / 3 = 1

3 // 4 = 0
3 / 4 = 0

3 // 5 = 0
3 / 5 = 0

3 // 6 = 0
3 / 6 = 0

3 // 7 = 0
3 / 7 = 0

3 // 8 = 0
3 / 8 = 0

3 // 9 = 0
3 / 9 = 0

4 // 1 = 4
4 / 1 = 4

4 // 2 = 2
4 / 2 = 2

4 // 3 = 1
4 / 3 = 1

4 // 4 = 1
4 / 4 = 1

4 // 5 = 0
4 / 5 = 0

4 // 6 = 0
4 / 6 = 0

4 // 7 = 0
4 / 7 = 0

4 // 8 = 0
4 / 8 = 0

4 // 9 = 0
4 / 9 = 0

5 // 1 = 5
5 / 1 = 5

5 // 2 = 2
5 / 2 = 2

5 // 3 = 1
5 / 3 = 1

5 // 4 = 1
5 / 4 = 1

5 // 5 = 1
5 / 5 = 1

5 // 6 = 0
5 / 6 = 0

5 // 7 = 0
5 / 7 = 0

5 // 8 = 0
5 / 8 = 0

5 // 9 = 0
5 / 9 = 0

6 // 1 = 6
6 / 1 = 6

6 // 2 = 3
6 / 2 = 3

6 // 3 = 2
6 / 3 = 2

6 // 4 = 1
6 / 4 = 1

6 // 5 = 1
6 / 5 = 1

6 // 6 = 1
6 / 6 = 1

6 // 7 = 0
6 / 7 = 0

6 // 8 = 0
6 / 8 = 0

6 // 9 = 0
6 / 9 = 0

7 // 1 = 7
7 / 1 = 7

7 // 2 = 3
7 / 2 = 3

7 // 3 = 2
7 / 3 = 2

7 // 4 = 1
7 / 4 = 1

7 // 5 = 1
7 / 5 = 1

7 // 6 = 1
7 / 6 = 1

7 // 7 = 1
7 / 7 = 1

7 // 8 = 0
7 / 8 = 0

7 // 9 = 0
7 / 9 = 0

8 // 1 = 8
8 / 1 = 8

8 // 2 = 4
8 / 2 = 4

8 // 3 = 2
8 / 3 = 2

8 // 4 = 2
8 / 4 = 2

8 // 5 = 1
8 / 5 = 1

8 // 6 = 1
8 / 6 = 1

8 // 7 = 1
8 / 7 = 1

8 // 8 = 1
8 / 8 = 1

8 // 9 = 0
8 / 9 = 0

9 // 1 = 9
9 / 1 = 9

9 // 2 = 4
9 / 2 = 4

9 // 3 = 3
9 / 3 = 3

9 // 4 = 2
9 / 4 = 2

9 // 5 = 1
9 / 5 = 1

9 // 6 = 1
9 / 6 = 1

9 // 7 = 1
9 / 7 = 1

9 // 8 = 1
9 / 8 = 1

9 // 9 = 1
9 / 9 = 1

>>> 

beweist (fast?) die ganze Zeit a/b entspricht a//b. Gibt es eine Zeit, die es nicht ist? Wenn nicht, warum enthielt Python 2 zwei Operatoren, die dasselbe tun?

5
user4913676

// ist der Floored-Divisionsoperator in Python. Das Ergebnis wird leicht erkennbar, wenn Sie versuchen, Gleitkommawerte zu teilen

# Python 2
>>> 10.0 / 3
3.3333333333333335
>>> 10.0 // 3
3.0

In Python2 wird für das Teilen von zwei Ints eine Ganzzahldivision verwendet, die Ihnen letztendlich dasselbe wie eine Bodendivision bietet. Sie können jedoch weiterhin // verwenden, um ein Bodenergebnis der Gleitkommadivision zu erhalten.

In Python3 führt das Teilen von zwei Ints zu einem Float, die Verwendung von // fungiert jedoch als Ganzzahldivision.

# Python3
>>> 10 / 3
3.3333333333333335
>>> 10 // 3
3

Wenn Sie (noch) in Python2 arbeiten, aber eines Tages in Python3 konvertieren möchten, sollten Sie immer // verwenden, wenn Sie zwei Teile teilen, oder from __future__ import division, um das Python3-Verhalten in Python2 abzurufen

13
Ryan Haining

In Python 2.7 müssen Sie für eine echte Division die Division aus einem Modul namens future importieren:

from __future__ import division

Dann ist der / die echte (schwebende) Division, Beispiel:

15 / 4 = 3.75

Und // ist die Ganzzahldivision (der ganzzahlige Teil der echten Division). Beispiel:

15 // 4 = 3
0
Mr Geek