J'ai deux valeurs entières aet b, mais j'ai besoin de leur rapport en virgule flottante. Je sais cela a < bet je veux calculer a / b, donc si j'utilise la division entière, j'obtiendrai toujours 0 avec un reste de a.

Comment puis-je forcer cà être un nombre à virgule flottante en Python dans ce qui suit?

c = a / b

En Python 2, la division de deux entiers produit un int. En Python 3, il produit un flottant. Nous pouvons obtenir le nouveau comportement en important depuis __future__.

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

Vous pouvez lancer pour flotter en faisant c = a / float(b). Si le numérateur ou le dénominateur est un flottant, le résultat sera également.

Une mise en garde: comme l'ont souligné les commentateurs, cela ne fonctionnera pas s'il bpourrait être autre chose qu'un nombre entier ou à virgule flottante (ou une chaîne représentant un). Si vous avez affaire à d'autres types (tels que des nombres complexes), vous devrez soit les vérifier, soit utiliser une méthode différente.

Comment puis-je forcer la division à être flottante en Python?

J'ai deux valeurs entières a et b, mais j'ai besoin de leur rapport en virgule flottante. Je sais que a <b et je veux calculer a / b, donc si j'utilise une division entière, j'obtiendrai toujours 0 avec un reste de a.

Comment puis-je forcer c à être un nombre à virgule flottante en Python dans ce qui suit?

c = a / b

Ce qui est vraiment demandé ici, c'est:

"Comment puis-je forcer une vraie division telle que a / bcela rendra une fraction?"

Mettre à niveau vers Python 3

En Python 3, pour obtenir une véritable division, il vous suffit de le faire a / b.

>>> 1/2
0.5

La division au sol, le comportement de division classique pour les entiers, est désormais a // b:

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

Cependant, vous pouvez être bloqué en utilisant Python 2, ou vous pouvez écrire du code qui doit fonctionner à la fois dans 2 et 3.

Si vous utilisez Python 2

En Python 2, ce n'est pas si simple. Certaines façons de gérer la division Python 2 classique sont meilleures et plus robustes que d'autres.

Recommandation pour Python 2

Vous pouvez obtenir le comportement de division Python 3 dans n'importe quel module avec l'importation suivante en haut:

from __future__ import division

qui applique ensuite la division de style Python 3 à l'ensemble du module. Il fonctionne également dans un shell python à tout moment donné. En Python 2:

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

C'est vraiment la meilleure solution car elle garantit que le code de votre module est plus compatible avec Python 3.

Autres options pour Python 2

Si vous ne souhaitez pas appliquer cela à l'ensemble du module, vous êtes limité à quelques solutions de contournement. Le plus populaire consiste à contraindre l'un des opérandes à un flotteur. Une solution robuste est a / (b * 1.0). Dans un nouveau shell Python:

>>> 1/(2 * 1.0)
0.5

Aussi robuste truedivdu operatormodule de operator.truediv(a, b), mais cela est probablement plus lent , car il est un appel de fonction:

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

Non recommandé pour Python 2

On le voit généralement a / float(b). Cela déclenchera une TypeError si b est un nombre complexe. Étant donné que la division avec des nombres complexes est définie, il est logique pour moi de ne pas faire échouer la division lors de la transmission d'un nombre complexe pour le diviseur.

>>> 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

Cela n'a pas beaucoup de sens pour moi de rendre votre code plus fragile.

Vous pouvez également exécuter Python avec l' -Qnewindicateur, mais cela a l'inconvénient d'exécuter tous les modules avec le nouveau comportement Python 3, et certains de vos modules peuvent s'attendre à une division classique, donc je ne le recommande que pour les tests. Mais pour démontrer:

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

c = a / (b * 1.0)

Dans Python 3.x, la barre oblique unique ( /) signifie toujours une véritable division (non tronquée). (L' //opérateur est utilisé pour tronquer la division.) En Python 2.x (2.2 et supérieur), vous pouvez obtenir ce même comportement en mettant un

from __future__ import division

en haut de votre module.

La simple création de l'un des paramètres de division au format virgule flottante produit également la sortie en virgule flottante.

Exemple:

>>> 4.0/3
1.3333333333333333

ou,

>>> 4 / 3.0
1.3333333333333333

ou,

>>> 4 / float(3)
1.3333333333333333

ou,

>>> float(4) / 3
1.3333333333333333

Ajoutez un point ( .) pour indiquer les nombres à virgule flottante

>>> 4/3.
1.3333333333333333

Cela fonctionnera également

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

Si vous souhaitez utiliser la division "true" (virgule flottante) par défaut, il existe un indicateur de ligne de commande:

python -Q new foo.py

Il y a quelques inconvénients (du PEP):

Il a été soutenu qu'une option de ligne de commande pour modifier la valeur par défaut est mauvaise. Cela peut certainement être dangereux entre de mauvaises mains: par exemple, il serait impossible de combiner un paquetage de bibliothèque tiers qui nécessite -Qnew avec un autre qui nécessite -Qold.

Vous pouvez en savoir plus sur les autres valeurs de drapeaux qui modifient / avertissent du comportement de la division en consultant la page de manuel python.

Pour plus de détails sur les changements de division, lisez: PEP 238 - Changement d'opérateur de division

from operator import truediv

c = truediv(a, b)

from operator import truediv

c = truediv(a, b)

où a est le dividende et b est le diviseur. Cette fonction est pratique lorsque le quotient après division de deux entiers est un flottant.