Python Language Division


Exemple

Python fait une division entière lorsque les deux opérandes sont des entiers. Le comportement des opérateurs de division de Python a changé depuis Python 2.x et 3.x (voir aussi Integer Division ).

a, b, c, d, e = 3, 2, 2.0, -3, 10
Python 2.x 2.7

En Python 2, le résultat de l'opérateur '/' dépend du type du numérateur et du dénominateur.

a / b                  # = 1 

a / c                  # = 1.5

d / b                  # = -2

b / a                  # = 0

d / e                  # = -1

Notez que comme a et b sont int s, le résultat est un int .

Le résultat est toujours arrondi au sol.

Parce que c est un flottant, le résultat de a / c est un float .

Vous pouvez également utiliser le module opérateur:

import operator        # the operator module provides 2-argument arithmetic functions
operator.div(a, b)     # = 1
operator.__div__(a, b) # = 1
Python 2.x 2.2

Et si vous voulez la division float:

Conseillé:

from __future__ import division # applies Python 3 style division to the entire module
a / b                  # = 1.5 
a // b                 # = 1

Ok (si vous ne voulez pas appliquer à tout le module):

a / (b * 1.0)          # = 1.5
1.0 * a / b            # = 1.5
a / b * 1.0            # = 1.0    (careful with order of operations)

from operator import truediv
truediv(a, b)          # = 1.5

Non recommandé (peut déclencher TypeError, par exemple si l'argument est complexe):

float(a) / b           # = 1.5
a / float(b)           # = 1.5
Python 2.x 2.2

L'opérateur '//' dans Python 2 force la division paralysée quel que soit le type.

a // b                # = 1
a // c                # = 1.0
Python 3.x 3.0

Dans Python 3, l'opérateur / effectue une division "true" indépendamment des types. L'opérateur // effectue la division d'étage et maintient le type.

a / b                  # = 1.5 
e / b                  # = 5.0
a // b                 # = 1
a // c                 # = 1.0

import operator            # the operator module provides 2-argument arithmetic functions
operator.truediv(a, b)     # = 1.5
operator.floordiv(a, b)    # = 1
operator.floordiv(a, c)    # = 1.0

Combinaisons possibles (types intégrés):

  • int et int (donne un int dans Python 2 et un float dans Python 3)
  • int et float (donne un float )
  • int et complex (donne un complex )
  • float et float (donne un float )
  • float et complex (donne un complex )
  • complex et complex (donne un complex )

Voir PEP 238 pour plus d'informations.