Wat is het verschil tussen ‘/’ en ‘//’ wanneer gebruikt voor deling?

Heeft het een voordeel om de ene boven de andere te gebruiken? In Python 2 lijken ze allebei dezelfde resultaten te geven:

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

Antwoord 1, autoriteit 100%

In Python 3.x retourneert 5 / 22.5en 5 // 2retourneert 2. De eerste is een drijvende-kommadeling en de laatste is verdiepingsdeling, ook wel integer-delinggenoemd.

In Python 2.2 of hoger in de 2.x-regel is er geen verschil voor gehele getallen, tenzij u een from __future__ import divisionuitvoert, waardoor Python 2.x het 3.x-gedrag overneemt .

Ongeacht de toekomstige import, 5.0 // 2retourneert 2.0aangezien dat het resultaat van de verdiepingsverdeling is van de bewerking.

Je kunt een gedetailleerde beschrijving vinden op https ://docs.python.org/whatsnew/2.2.html#pep-238-change-the-division-operator

Antwoord 2, autoriteit 10%

Python 2.x verduidelijking:

Ter verduidelijking voor de Python 2.x-regel: /is geen verdiepingsverdeling of echte verdeling.

/is verdiepingsdeling wanneer beideargumenten intzijn, maar is echte deling wanneer een van beidevan de argumenten zijn float.

Antwoord 3, autoriteit 5%

//implementeert “verdiepingsverdeling”, ongeacht uw type. Dus
1.0/2.0geeft 0.5, maar zowel 1/2, 1//2als 1.0//2.0geeft 0.

Zie https://docs.python .org/whatsnew/2.2.html#pep-238-change-the-division-operatorvoor details

Antwoord 4, autoriteit 4%

/–> Drijvende komma verdeling

//–> Verdieping

Laten we enkele voorbeelden bekijken in zowel Python 2.7 als Python 3.5.

Python 2.7.10 versus Python 3.5

print (2/3)  ----> 0                   Python 2.7
print (2/3)  ----> 0.6666666666666666  Python 3.5

Python 2.7.10 versus Python 3.5

 print (4/2)  ----> 2         Python 2.7
  print (4/2)  ----> 2.0       Python 3.5

Als u nu (in python 2.7) dezelfde uitvoer wilt hebben als in python 3.5, kunt u het volgende doen:

Python 2.7.10

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

Terwijl er geen verschil is tussen verdiepingsdeling in zowel python 2.7 als 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

Antwoord 5, autoriteit 3%

Zoals iedereen al heeft geantwoord, is //verdiepingsdeling.

Waarom dit belangrijk is, is dat //ondubbelzinnig een verdiepingsindeling is, in alle Python-versies vanaf 2.2, inclusief Python 3.x-versies.

Het gedrag van /kan veranderen afhankelijk van:

• Actieve __future__import of niet (module-local)
• Python-opdrachtregeloptie, ofwel -Q oldof -Q new

Antwoord 6, autoriteit 2%

>>> print 5.0 / 2
2.5
>>> print 5.0 // 2
2.0

Antwoord 7

Python 2.7 en andere aankomende versie van python:

• Divisie (/)

Verdeelt linkerhand operand door rechterhand operand

Voorbeeld: 4 / 2 = 2

• Verdieping Verdeling (//)

De verdeling van operanden waarbij het resultaat het quotiënt is waarin de cijfers achter de komma worden verwijderd. Maar als een van de operanden negatief is, wordt het resultaat gevloerd, d.w.z. vanaf nul afgerond (in de richting van negatief oneindig):

Voorbeelden: 9//2 = 4en 9.0//2.0 = 4.0, -11//3 = -4, -11.0//3 = -4.0

Zowel de /Division- als de //verdiepingsdivisie-operator werken op dezelfde manier.

Antwoord 8

De dubbele schuine streep, //, is verdiepingsdeling:

>>> 7//3
2

Antwoord 9

//is verdiepingsdeling, het geeft je altijd de gehele verdieping van het resultaat. De andere is de ‘gewone’ verdeling.

Antwoord 10

Het antwoord van de vergelijking wordt afgerond op het eerstvolgende kleinere gehele getal of zwevend met .0 als decimaalteken.

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

Antwoord 11

De bovenstaande antwoorden zijn goed. Ik wil nog een punt toevoegen. Tot sommige waarden resulteren beiden in hetzelfde quotiënt. Na die vloerafdeling (//) werkt prima, maar geen divisie (/) operator:

>>> int(755349677599789174 / 2) # wrong answer
377674838799894592

>>> 755349677599789174 // 2     # correct answer
377674838799894587

Antwoord 12

• //is vloerafdeling, het zal u altijd de vloerwaarde van het resultaat geven.
• en de andere /is de drijvende divisie.

Volgsels zijn het verschil tussen /en //;
Ik heb deze rekenbewerkingen 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

Antwoord 13

Python 3.x verduidelijking

Gewoon om enkele eerdere antwoorden aan te vullen.

Het is belangrijk om op te merken dat:

A // B

• is vloerafdeling . Zoals in:

  MATH.VLOOR (A / B)

• is niet int divisie . Zoals in:

  INT (A / B)

• is niet rond tot 0 float divisie . Zoals in:

  Ronde (A / B, 0)

Dientengevolge is de manier van gedrag verschillend als het gaat om positieven van een negatievennummers zoals in het volgende voorbeeld:

1 // 2 is 0, zoals in:

math.floor(1/2)

-1 // 2 is -1, zoals in:

math.floor(-1/2)

Antwoord 14

Python 3

Operatie	Resultaat	Opmerkingen
x / y	quotiënt van xen y
x // y	geminimaliseerd quotiënt van xen y	(1)

---

Antwoord 15

Samenvatting

• x//y : EXACTgeheel getal delen
• int(x/y) OR math.floor(x/y): INEXACTgeheel getal delen (maar bijna correct)
• x/y: deling met drijvende komma (met verlies aan significantie)

Opmerkelijk resultaat van de berekening

import math
N = 1004291331219602346 # huge number 
print(N//100) #=> 10042913312196023 is correct answer
print(math.floor(N/100)) #=> 10042913312196024 is wrong answer
print(math.ceil(N/100)) #=> 10042913312196024 is wrong answer
print(int(N/100)) #=> 10042913312196024 is wrong answer

Overweging

Ik denk na over de evaluatie van int(x/y).
Python evalueert eerst de uitdrukking x/yen krijgt INEXACT zwevend getal z.
Ten tweede evalueert Python de uitdrukking int(z).
We krijgen een verkeerd resultaat als het verlies aan significantie niet kan worden genegeerd.

---

Antwoord 16

5.0//2resulteert in 2.0en niet in 2omdat het retourtypevan de retourwaarde van //operator volgt python dwang (type casting) regels.

Python bevordert de conversie van een lager gegevenstype (integer) naar een hoger gegevenstype (float) om gegevensverlies te voorkomen.