Partie entière en Python : 3 méthodes simples avec exemples

Pour obtenir la partie entière d’un nombre réel en Python, utilisez la fonction floor() du module math : math.floor(x). La fonction renvoie le plus grand entier inférieur ou égal à x.

La partie entière d’un nombre réel \(x\), notée \(\lfloor x \rfloor\), désigne le plus grand entier inférieur ou égal à \(x\). Ainsi, \(\lfloor 4.3 \rfloor = 4\), tandis que \(\lfloor -2.8 \rfloor = -3\), et non pas \(-2\).

Utiliser la fonction floor()

Ainsi, en python dans la bibliothèque math on peut utiliser la fonction floor pour obtenir directement la partie entière.

Il faut d’abord importer la fonction depuis le module math, puis lui transmettre le nombre dont on veut calculer la partie entière.

Exemple :

from math import floor
print(floor(4.3))
print(floor(-2.8))

Le résultat est respectivement 4 et -3.

Exemples avec des nombres positifs et négatifs

Soit \( x = 4.3 \), alors \( \displaystyle \lfloor x \rfloor = 4 \), car \( 4 \) est le plus grand entier inférieur à 4.

Soit \( x = -2.8 \), alors \( \displaystyle \lfloor x \rfloor = -3 \) et non pas \( - 2 \), car \( - 3 \) est le plus grand entier inférieur à \( - 2.8 \).

Soit \( x = 6 \), alors \( \displaystyle \lfloor x \rfloor = 6 \) car 6 est entier. Or, la partie entière renvoie le plus grand entier inférieur ou égal à \( x \).

En Python, ces exemples s’écrivent de la manière suivante :

from math import floor
print(floor(4.3))
print(floor(-2.8))
print(floor(6))

Cas particuliers

Tu peux déjà retenir que la partie entière de zéro est zéro. Ici pas d’exceptions particulières !

\[ \lfloor 0 \rfloor = 0 \]

Si on prend une valeur de \( x \) qui semble très proche d’un entier supérieur, tel que \( 4.99999999 \) qui est proche de \( 5 \). La partie entière reste le plus grand entier inférieur, donc ici \( \displaystyle \lfloor 4.99999999 \rfloor = 4 \).

En Python :

from math import floor
print(floor(0))
print(floor(4.99999999))

Le résultat de floor(4.99999999) est donc 4, car le nombre est inférieur à 5.

La partie entière d’une valeur absolue

On peut aussi s’intéresser à la valeur absolue avec la partie entière. En effet, c’est un cas particulier très simple, puisque dès que la partie entière de \( \displaystyle |x| \) est simplement l’entier de \( x \).

Ainsi, avec avec \( x = 3.2 \), alors \( \lfloor |x| \rfloor = \lfloor 3.2 \rfloor = 3 \).

Ainsi, avec \( x = - 4.7 \), on a \( \lfloor |x| \rfloor = \lfloor 4.7 \rfloor = 4 \).

En Python, on peut utiliser la fonction intégrée abs() avant d’appeler floor() :

from math import floor
print(floor(abs(3.2)))
print(floor(abs(-4.7)))

L’encadrement caractéristique

Grâce à la partie entière, on peut encadrer \( x \) et cet encadrement est fondamental, car tu le retrouveras dans de nombreux exercices.

Ainsi, pour tout \( x \in \mathbb{R} \)

\[ \lfloor x \rfloor \leq x < \lfloor x \rfloor + 1 \]

Cette propriété signifie que la partie entière est toujours inférieure ou égale au nombre, et que le nombre reste strictement inférieur à l’entier suivant.

Pour \(x = 4.3\), on obtient :

\[ 4 \leq 4.3 < 5 \]

Pour \(x = -2.8\), on obtient :

\[ -3 \leq -2.8 < -2 \]

Cette dernière égalité explique pourquoi la partie entière de \(-2.8\) est \(-3\) : \(-3\) est le plus grand entier qui reste inférieur ou égal à \(-2.8\).

La partie fractionnaire

La différence \( \displaystyle x - \lfloor x \rfloor \) est appelée la partie fractionnaire de \( x \), notée \( \{x\} \).

Elle représente la partie décimale de \( x \) et elle est donc compris entre 0 et 1.

\[ 0 \leq x - \lfloor x \rfloor < 1 \]

Par exemple, avec \( x = 3.2 \) on alors :

\[ \lfloor x \rfloor = 3 \quad \text{d’où} \quad \{x\} = 3.2 - 3 = 0.2 \]

En Python, la partie fractionnaire peut être calculée en soustrayant la partie entière au nombre initial :

from math import floor
x = 3.2
partie_fractionnaire = x - floor(x)
print(partie_fractionnaire)

Le résultat attendu est 0.2.

Ne pas confondre floor() et une conversion en int

La fonction floor() et la conversion int() donnent le même résultat pour certains nombres positifs, mais leur comportement diffère pour les nombres négatifs.

La partie entière d’un nombre réel \( x \), notée \( \displaystyle \lfloor x \rfloor \), désigne le plus grand entier inférieur ou égal à \( x \).

Pour \(x = -2.8\), la partie entière mathématique vaut donc \(-3\), tandis que la conversion en entier supprime la partie décimale en se rapprochant de zéro :

from math import floor
x = -2.8
print(floor(x))
print(int(x))

Le premier résultat est -3, alors que le second est -2. Si l’objectif est réellement de calculer la partie entière mathématique, il faut utiliser floor().

Division entière avec l’opérateur //

Si vous souhaitez obtenir une division entière (c'est-à-dire dont le résultat - tronqué - ne peut être qu'un entier), vous devez utiliser l'opérateur //.

En Python, l’opérateur // réalise la division entière de deux valeurs, tandis que l’opérateur % calcule le reste de la division entière.

Opérateur	Description	Exemple
/	Réalise la division de deux valeurs	value = 10 / 5
//	Réalise la division entière de deux valeurs	value = 5 // 3
%	Calcule le reste de la division entière de deux valeurs	value = 5 % 3

En Python 3, l'opérateur de division / effectue une division réelle.

Veuillez bien noter que ceci est l'un des changements de syntaxe apportés à la version 3 de Python, par rapport aux versions précédentes.

Par exemple :

20 / 3
20 // 3

La division avec / produit un nombre réel, alors que la division avec // produit une division entière.

Pour deux entiers positifs, // permet donc d’obtenir la partie entière du quotient :

5 // 3 vaut 1.

Avec des nombres négatifs, l’opérateur // suit le comportement de la division entière par plancher, et non celui d’une simple suppression des chiffres après la virgule.

-5 // 3 vaut donc -2, car \(-2\) est le plus grand entier inférieur ou égal à \(-5/3\).

Quotient et reste avec divmod()

Etant donné deux entiers a et b, en Python les résultats de la division euclidienne peuvent s’obtenir de différentes façons :

q = a // b retourne le quotient de la division euclidienne
r = a%b retourne le reste de la division euclidienne
q, r = divmod(a, b) retourne en même temps le quotient et le reste

La fonction divmod() est utile lorsque l’on veut récupérer simultanément la partie entière du quotient et le reste :

q, r = divmod(20, 3)
print(q)
print(r)

Le quotient entier est 6 et le reste est 2.

Différence entre partie entière et partie décimale d’un flottant

La partie entière et la partie décimale correspondent à deux opérations différentes.

La fonction floor(x) renvoie la partie réelle de x. Du coup, en soustrayant la partie réelle tu obtiens la partie décimale de ton nombre !

Pour \(x = 2.051\), l’idée consiste donc à calculer :

from math import floor
nb = 2.051
partie_entiere = floor(nb)
partie_decimale = nb - partie_entiere

La partie entière vaut 2 et la partie décimale mathématique est proche de 0.051.

Les nombres à virgule flottante ne représentent toutefois pas toujours exactement les valeurs décimales utilisées en écriture courante.

Python 3.x .

>>> nb = 2.051
>>> print(nb%1)
0.051000000000000156

Il n'y aura pas un problème de précision ?

En effet, il ne doit pas y avoir grand chose à faire, que de se faire une raison.

Que l'imprécision sur des float, ne permet pas d'avoir la valeur de la partie décimale de cette façon.

Autrement dit la différence entre 0.51 et 0.50999999999 est un epsilon qu'il faut de toute façon gérer lorsqu'on s'amuse avec des "float".

Pourquoi les flottants peuvent-ils produire de petites différences ?

Notez aussi que dans le monde de l'informatique, les nombres réels sont souvent désignés comme des nombres « à virgule flottante » (floating point numbers).

Les nombres flottants sont représentés selon un format binaire, et certaines valeurs décimales simples ne peuvent pas être stockées exactement sous cette forme.

Avec une valeur comme 2.051, Python peut donc afficher une représentation proche de la valeur mathématique, mais légèrement différente :

nb = 2.051
print(nb - floor(nb))

Le résultat peut apparaître sous la forme 0.051000000000000156.

Cette différence ne signifie pas que floor() a mal fonctionné : la fonction renvoie correctement la partie entière du flottant effectivement représenté en mémoire.

Arrondir l’affichage de la partie fractionnaire

Si l’on souhaite seulement afficher un nombre limité de chiffres après la virgule, on peut utiliser round() ou un formatage.

nb=2.051
ni=int(abs(nb))
deci=nb-ni
print(round(deci, 3))

Le résultat affiché est 0.051.

On peut également contrôler le nombre de chiffres affichés avec un format :

print('%.2f' % (2.51 - 2))
print('%.3f' % (2.51 - 2))
print('%.5f' % (2.51 - 2))

Les résultats sont respectivement affichés sous les formes 0.51, 0.510 et 0.51000.

Ce formatage modifie l’affichage, mais il ne transforme pas nécessairement la valeur interne du flottant en représentation décimale exacte.

Utiliser Decimal pour les calculs décimaux

C'est em. lorsqu'on fait de la comptabilité mais dans ce cas on n'utilise pas des "float" mais plutôt Decimal ou autre.

Le type Decimal est adapté aux situations dans lesquelles la représentation décimale exacte est importante.

from decimal import Decimal
nb = Decimal("2.051")
partie_entiere = int(nb)
partie_decimale = nb - partie_entiere

Il est préférable de construire un Decimal à partir d’une chaîne de caractères lorsque l’on veut conserver exactement les chiffres décimaux saisis.

Calculer la partie entière d’une saisie utilisateur

Vous pouvez utiliser la fonction input pour demander la saisie d'une valeur à partir de la console.

Mais attention, cette fonction renvoie une chaîne de caractères.

Si vous souhaitez obtenir une valeur entière, il faudra donc convertir la chaîne de caractères en une instance de la classe int.

str_value = input("Veuillez saisir une valeur numérique entière : ")
value = int(str_value)

Pour saisir un nombre réel puis calculer sa partie entière, il faut convertir la saisie en float, puis appliquer floor() :

from math import floor
str_value = input("Veuillez saisir un nombre : ")
value = float(str_value)
print(floor(value))

Le séparateur décimal utilisé dans le code Python est le point et non la virgule.

Veuillez remarquer au passage ce qui est la règle dans tous les langages de programmation, à savoir que les conventions mathématiques de base sont celles qui sont en vigueur dans les pays anglophones : le séparateur décimal y est donc toujours un point, et non une virgule comme chez nous.

Applications avec la division euclidienne

Le théorème de la division euclidienne dans les entiers naturels (les nombres entiers pris à partir de 0) s'énonce ainsi : À deux entiers naturels a et b, b ≠ 0, on associe de façon unique deux entiers naturels, le quotient q et le reste r, qui vérifient :

\[ a = bq + r \]

\[ r < b \]

Déterminer si a est divisible par b consiste donc à vérifier que le reste r de la division euclidienne de a par b est nul.

Ce qui se traduit en Python par : a % b == 0.

Le caractère ‘%’, qui sert à obtenir le reste de la division entière a par b, nécessite une petite astuce pour l’obtenir via le clavier de la calculatrice Numworks.

Pour calculer le quotient et le reste d’une division, on peut écrire :

a = 1984
b = 100
q = a // b
r = a % b

1984 // 100 donne 19, tandis que 1984 % 100 donne 84.

Extraire les derniers chiffres d’un nombre

Pour calculer les 5 derniers chiffres d'un nombre \(n\) très grand.

On peut faire n % 100_000, ou bien n % 10**5 .

>>> 2**2021 % 10**5
37152

Les derniers chiffres de \(2^{2021}\) sont 37152.

Cette technique utilise le modulo, et non directement la partie entière, mais elle repose sur la division entière et le reste associés à un entier.

Entiers très grands et séparateurs de chiffres

Contrairement à d'autres langages de programmation, en Python, un entier n'est pas limité dans sa plage de valeurs.

Vous pouvez manipuler des valeurs entières nécessitant des milliers de chiffres pour être exprimé.

Avec une version récente de Python, on peut utiliser le caractère _ (tiret-bas) comme séparateur de milliers, millions, etc.

En bref : 100_000 est plus lisible que 100000.

100 000 provoque une erreur, il manque le tiret-bas.

On recommande de le faire pour les nombres à partir de 5 chiffres.

counter = 10_000_000_000

La valeur stockée dans cette variable est dix milliards, mais l’écriture avec des tirets-bas facilite sa lecture.

Partie entière et types numériques

Nous avons déjà utilisé le type int (la classe int, si vous préférez) : il permet d'exprimer des valeurs entières.

Pour rappel, voici comment définir une variable contenant une valeur entière.

value = 123
print(value)
type(value)

Le résultat de type(value) est <class 'int'>.

Sous Python, il n'est pas nécessaire d'écrire des lignes de programme spécifiques pour définir le type des variables avant de pouvoir les utiliser.

Il vous suffit en effet d'assigner une valeur à un nom de variable pour que celle-ci soit automatiquement créée avec le type qui correspond au mieux à la valeur fournie.

Dans l'exercice précédent, par exemple, les variables n, msg et pi ont été créées automatiquement chacune avec un type différent (« nombre entier » pour n, « chaîne de caractères » pour msg, « nombre à virgule flottante » (ou « float », en anglais) pour pi).

Le typage dynamique permet notamment de manipuler naturellement des entiers, des flottants et les résultats obtenus avec floor().

Pièges fréquents

Ne pas confondre floor(x) et int(x) pour les valeurs négatives.
Ne pas utiliser une virgule comme séparateur décimal dans une valeur Python.
Ne pas oublier d’importer floor depuis le module math.
Ne pas confondre division réelle /, division entière // et reste %.
Ne pas interpréter une petite différence d’affichage d’un flottant comme une erreur de calcul de la partie entière.