Comment puis-je forcer la division à être une virgule flottante? La division continue à arrondir à 0?
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 que je veux calculer a / b, donc si j'utilise une division entière, j'aurai toujours 0 avec un reste de a.
Comment puis-je forcer c à être un nombre à virgule flottante dans Python dans la suite?
c = a / b
Dans Python 2, la division de deux ints produit un int. Dans Python 3, il produit un float. 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 le flot 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 si b pourrait être autre chose qu'un nombre entier ou un nombre à virgule flottante (ou une chaîne en représentant un). Si vous utilisez peut-être d'autres types (tels que des nombres complexes), vous devez les vérifier ou utiliser une méthode différente.
Comment puis-je forcer la division à être un point flottant 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 que je veux calculer a/b, donc si j'utilise la division entière, j'obtiendrai toujours de 0 avec le reste de a.
Comment puis-je forcer c à être un nombre à virgule flottante dans Python dans la suite?
c = a / b
Ce qui est vraiment demandé ici est:
"Comment puis-je forcer une division vraie telle que a / b renverra une fraction?"
Mettre à niveau vers Python 3
Dans Python 3, pour obtenir une véritable division, il vous suffit de faire a / b.
>>> 1/2
0.5
La division du sol, le comportement classique de la division pour les entiers, est maintenant a // b:
>>> 1//2
0
>>> 1//2.0
0.0
Cependant, il se peut que vous soyez bloqué avec Python 2 ou que vous écriviez du code devant fonctionner à la fois en 2 et en 3.
Si vous utilisez Python 2
Dans Python 2, ce n'est pas si simple. Certaines manières de traiter avec la division classique Python 2 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. Cela fonctionne également dans un shell python à tout moment. Dans 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 davantage compatible avec la version 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 flottant. Une solution robuste est a / (b * 1.0). Dans un nouveau Python Shell:
>>> 1/(2 * 1.0)
0.5
Également robuste est truediv du module operator, operator.truediv(a, b), mais cela est probablement plus lent parce que c'est un appel de fonction:
>>> from operator import truediv
>>> truediv(1, 2)
0.5
Non recommandé pour Python 2
On voit couramment a / float(b). Cela générera une erreur 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 laisser la division échouer lorsque nous passons 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 de rendre délibérément votre code plus fragile.
Vous pouvez également exécuter Python avec l'indicateur -Qnew, mais cela présente l'inconvénient d'exécuter tous les modules avec le nouveau comportement Python 3, et certains de vos modules peuvent s'attendre à des performances classiques. division, donc je ne recommande pas cela, sauf 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 simple barre oblique (/) signifie toujours une division vraie (sans troncature). (L'opérateur // est utilisé pour tronquer la division.) Dans Python 2.x (2.2 et versions supérieures), vous pouvez obtenir le même comportement en mettant un
from __future__ import division
en haut de votre module.
Le simple fait de définir l'un des paramètres de division en 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
Ajouter un point (.) pour indiquer les nombres en virgule flottante
>>> 4/3.
1.3333333333333333
Cela fonctionnera aussi
>>> 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é avancé qu’une option en ligne de commande pour modifier la valeur par défaut est néfaste. Cela peut certainement être dangereux entre de mauvaises mains: par exemple, il serait impossible de combiner un paquet 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/mettent en garde le comportement de la division en consultant la page de manuel python.
Pour plus de détails sur les changements de division, lire: PEP 238 - Changement d’opérateur de division
si vous faites une division de deux entiers python vous retournera un entier, alors vous devez faire:
c = float(a)/b
ou
c = a/float(b)
et ensuite obtenir c en tant que type float
from operator import truediv
c = truediv(a, b)
Cela fonctionnera aussi
u = 1./5 imprimer u
0.2répondu 24 décembre '13 à 19:58 Gaurav Agarwal 6,7172279140
Merci Gauraw, cela fait l'affaire et c'est une solution plutôt soignée. Si le numérateur et le dénominateur sont des variables, la "solution" peut être multipliée par 1. par le quotient.
Exemple:
aa = 2
bb = 3
aa / bb = 0
1. * aa / bb = 0.6666666666666666
;-)
Max - Italie
from operator import truediv
c = truediv(a, b)
où a est dividende et b est le diviseur. Cette fonction est pratique lorsque quotient après division de deux nombres entiers est un float.