Ik heb twee gehele waarden aen b, maar ik heb hun verhouding in drijvende komma nodig. Ik weet dat a < ben ik wil a / bberekenen, dus als ik deling met gehele getallen gebruik, krijg ik altijd 0 met een rest van a.

Hoe kan ik ervoor zorgen dat cin het volgende een getal met drijvende komma is in Python 2?

c = a / b

Antwoord 1, autoriteit 100%

In Python 2 levert de deling van twee ints een int op. In Python 3 produceert het een float. We kunnen het nieuwe gedrag verkrijgen door te importeren uit __future__.

>>> from __future__ import division
>>> a = 4
>>> b = 6
>>> c = a / b
>>> c
0.66666666666666663

Antwoord 2, autoriteit 88%

Je kunt casten naar float door c = a / float(b)te doen. Als de teller of noemer een float is, dan is het resultaat dat ook.

Een waarschuwing: zoals commentatoren hebben opgemerkt, werkt dit niet als biets anders is dan een geheel getal of een getal met drijvende komma (of een tekenreeks die er een vertegenwoordigt). Als je te maken hebt met andere typen (zoals complexe getallen), moet je deze controleren of een andere methode gebruiken.

Antwoord 3, autoriteit 24%

Hoe kan ik deling dwingen om een ​​drijvende komma te zijn in Python?

Ik heb twee gehele waarden a en b, maar ik heb hun verhouding in drijvende komma nodig. Ik weet dat een < b en ik wil a/b berekenen, dus als ik deling met gehele getallen gebruik, krijg ik altijd 0 met een rest van a.

Hoe kan ik ervoor zorgen dat c in het volgende een getal met drijvende komma is in Python?

c = a / b

Wat hier echt wordt gevraagd is:

“Hoe forceer ik een echte deling zodat a / been breuk oplevert?”

Upgrade naar Python 3

In Python 3, om echte deling te krijgen, doe je gewoon a / b.

>>> 1/2
0.5

Vloerdeling, het klassieke delingsgedrag voor gehele getallen, is nu a // b:

>>> 1//2
0
>>> 1//2.0
0.0

Het kan echter zijn dat je vastloopt met Python 2 of dat je code schrijft die zowel in 2 als in 3 moet werken.

Bij gebruik van Python 2

In Python 2 is het niet zo eenvoudig. Sommige manieren om met de klassieke Python 2-divisie om te gaan zijn beter en robuuster dan andere.

Aanbeveling voor Python 2

Je kunt het delingsgedrag van Python 3 krijgen in een bepaalde module met de volgende import bovenaan:

from __future__ import division

die vervolgens de indeling in Python 3-stijl op de hele module toepast. Het werkt ook op elk willekeurig punt in een python-shell. In Python 2:

>>> from __future__ import division
>>> 1/2
0.5
>>> 1//2
0
>>> 1//2.0
0.0

Dit is echt de beste oplossing omdat het ervoor zorgt dat de code in je module meer compatibel is met Python 3.

Andere opties voor Python 2

Als u dit niet op de hele module wilt toepassen, bent u beperkt tot een paar tijdelijke oplossingen. De meest populaire is om een ​​van de operanden tot een float te dwingen. Een robuuste oplossing is a / (b * 1.0). In een nieuwe Python-shell:

>>> 1/(2 * 1.0)
0.5

Ook robuust is truedivvan de operator-module operator.truediv(a, b), maar dit is waarschijnlijk langzamer omdat het een functie is bel:

>>> from operator import truediv
>>> truediv(1, 2)
0.5

Niet aanbevolen voor Python 2

Vaak gezien is a / float(b). Dit zal een TypeError opleveren als b een complex getal is. Aangezien deling met complexe getallen is gedefinieerd, is het voor mij logisch om de deling niet te laten mislukken wanneer een complex getal voor de deler wordt doorgegeven.

>>> 1 / float(2)
0.5
>>> 1 / float(2j)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't convert complex to float

Het heeft voor mij weinig zin om je code doelbewust brozer te maken.

Je kunt Python ook uitvoeren met de vlag -Qnew, maar dit heeft als nadeel dat alle modules met het nieuwe Python 3-gedrag worden uitgevoerd, en sommige van je modules kunnen klassieke deling verwachten, dus ik doe het niet Ik raad dit niet aan, behalve om te testen. Maar om te demonstreren:

$ python -Qnew -c 'print 1/2'
0.5
$ python -Qnew -c 'print 1/2j'
-0.5j

Antwoord 4, autoriteit 16%

c = a / (b * 1.0)

Antwoord 5, autoriteit 8%

In Python 3.x betekent de enkele schuine streep (/) altijd echte (niet-afkortende) deling. (De operator //wordt gebruikt voor het afkappen van delen.) In Python 2.x (2.2 en hoger) kun je hetzelfde gedrag krijgen door een

from __future__ import division

bovenaan je module.

Antwoord 6, autoriteit 4%

Alleen het maken van een van de parameters voor deling in drijvende-komma-indeling produceert ook de uitvoer in drijvende-komma.

Voorbeeld:

>>> 4.0/3
1.3333333333333333

of,

>>> 4 / 3.0
1.3333333333333333

of,

>>> 4 / float(3)
1.3333333333333333

of,

>>> float(4) / 3
1.3333333333333333

Antwoord 7, autoriteit 3%

Voeg een punt toe (.) om getallen met drijvende komma aan te geven

>>> 4/3.
1.3333333333333333

Antwoord 8, autoriteit 2%

Dit werkt ook

>>> u=1./5
>>> print u
0.2

Antwoord 9

Als u standaard “true” (floating point) deling wilt gebruiken, is er een opdrachtregelvlag:

python -Q new foo.py

Er zijn enkele nadelen (van de PEP):

Er is beweerd dat een opdrachtregeloptie om de
standaard is slecht. Het kan zeker gevaarlijk zijn in de verkeerde
handen: het zou bijvoorbeeld onmogelijk zijn om een ​​3e . te combineren
partijbibliotheekpakket dat -Qnew vereist met een ander dat
vereist -Qold.

Je kunt meer te weten komen over de andere vlagwaarden die het gedrag van deling veranderen/waarschuwingen door naar de man-pagina van Python te kijken.

Voor volledige details over divisiewijzigingen, lees: PEP 238 — De divisie-operator wijzigen

Antwoord 10

from operator import truediv
c = truediv(a, b)

Antwoord 11

from operator import truediv
c = truediv(a, b)

waarbij a het deeltal is en b de deler.
Deze functie is handig wanneer het quotiënt na deling van twee gehele getallen een float is.