Comment effectuer une division par étage en Python

Dans ce tutoriel, vous apprendrez à effectuer une division par le sol en Python. Vous utiliserez l'opérateur // de Python, la fonction floor du module mathématique de Python, et plus encore - avec des exemples de code.

Nous commencerons par un aperçu des opérateurs arithmétiques en Python et nous apprendrons comment fonctionne l'opérateur de division par le sol //. Ensuite, nous apprendrons à utiliser d'autres méthodes équivalentes, y compris les fonctions des modules math et operator, pour effectuer une division par le sol.

Commençons...

Opérateurs arithmétiques en Python

En Python, vous pouvez utiliser les opérateurs arithmétiques pour effectuer des opérations arithmétiques simples sur les nombres de type int et float. Ces opérateurs agissent sur les opérandes (les nombres) et renvoient le résultat de l'opération.

Le tableau suivant résume les opérateurs arithmétiques de Python et leur fonctionnement :

Prenons quelques exemples qui utilisent ces opérateurs arithmétiques. Vous pouvez tester ces exemples dans une REPL Python ou dans l'éditeur Python en ligne de Geekflare.

>>> num1 = 18
>>> num2 = 5

>>> num1 num2
23

>>> num1 - num2
13

>>> num1 * num2
90

>>> num1 ** num2
1889568

Dans cet exemple, num1 est 18 et num2 est 5. L'opération de division num1/num2 renvoie le résultat, y compris la partie fractionnaire.

Le nombre 5 entre trois fois dans 18, ce qui laisse un reste de trois. Par conséquent, l'opération de division par le sol, num1//num2, donne le quotient 3, tandis que l'opérateur modulo donne le reste - également 3 dans ce cas.

>>> num1/num2
3.6

>>> num1//num2
3

>>> num1 % num2
3

Cela devrait vous donner une idée du fonctionnement des opérateurs de division, de division par étage et de modulo. Nous allons maintenant étudier en détail l'opérateur de division par le sol.

⚠️ Dans Python 2, l'opération de division (/) tronque le résultat à l'entier le plus proche, ce qui est similaire à l'opération de division par le sol dans Python 3. Ce tutoriel explique comment fonctionne l'opération de division par le sol dans Python 3.x.

Division par le sol à l'aide de l'opérateur //

Considérons une opération de division avec un dividende et un diviseur. Dans num1/num2, num1 est le dividende et num2 est le diviseur. Pour effectuer une division par le sol de num1 et num2, utilisez num1//num2.

L'opérateur de division par le sol (//) renvoie le quotient de l'opération de division sous la forme d'un entier ou d'un nombre à virgule flottante, en fonction des types de données des opérandes.

L'opérateur de division floor ne garantit pas que la réponse soit toujours un entier. Si le dividende(num1) ou le diviseur(num2) est un nombre flottant, le résultat de num1//num2 est un nombre flottant. Voici quelques exemples.

>>> 18,0//5
3,0
>>> 10,0//4
2,0
>>> 15//4,0
3,0

Si le résultat doit être un entier, vous devez le convertir explicitement en entier à l'aide de la fonction int( ) :

>>> int(18.0//5)
3
>>> int(10.0//4)
2
>>> int(15//4.0)
3

Que se passe-t-il sous le capot ?

Lorsque vous utilisez l'opérateur de division floor //, la méthode spéciale (également appelée méthode dunder) __floordiv__( ) est appelée. Par conséquent, vous pouvez également utiliser la méthode __floordiv__() sur n'importe quel nombre entier ou à virgule flottante, comme indiqué ci-dessous :

num1 = 18
num2 = 5
num1.__floordiv__(num2)
# Sortie : 3

Division par le plancher à l'aide de operator.floordiv()

💡 Pour effectuer une division par le sol en Python, vous pouvez également utiliser la fonctionfloordiv() du module operator.

Le opérateur de module de Python contient les définitions de fonctions efficaces qui peuvent effectuer toutes les opérations arithmétiques. Par conséquent, pour effectuer une division par le bas, vous pouvez également utiliser la fonction floordiv() du module operator - au lieu de l'opérateur //.

L'utilisation de la fonction floordiv() du module operator est équivalente à l'utilisation de l'opérateur de division par le sol.

>>> import operator
>>> operator.floordiv(18,5)
# Output : 3
>>> operator.floordiv(12,5.0)
# Sortie : 2.0

Division par le plancher à l'aide de math.floor()

Comment fonctionne la fonction Floor ?

En mathématiques, la fonction floor() prend en entrée un nombre réel x et renvoie un entier (résultat). Ce résultat est le plus grand nombre entier inférieur ou égal au nombre réel x.

Pour mieux comprendre, prenons quelques exemples et visualisons ces nombres sur une droite numérique.

Exemple 1: considérons le nombre 2,3. Le plus grand nombre entier inférieur ou égal à 2,3 est 2 ; floor(2,3) renvoie donc 2.

Exemple 2 : Vous pouvez appliquer la même définition aux nombres négatifs. Considérez le nombre -1,7. Le plus grand entier inférieur ou égal à -1,7 est -2 ; floor(-1,7) renvoie donc -2.

Vérifions les résultats ci-dessus en utilisant la fonction floor() du module math.

>>> from math import floor
>>> floor(2.3)
2
>>> floor(-1.7)
-2

Pour effectuer une division par le sol, vous pouvez appeler la fonction floor() avec num1/num2 comme argument. Comme elle tronque ou arrondit le résultat à l'entier inférieur le plus proche, elle est équivalente à l'opération de division par le sol.

Vous pouvez importer explicitement la fonction floor() à partir du module math, comme indiqué ci-dessous :

from math import floor
num1 = 18
num2 = 5
floor(num1/num2)
# Output : 3

Vous pouvez également importer uniquement le module math et accéder à la fonction floor() à l'aide de math.floor().

import math
num1 = 18
num2 = 5
math.floor(num1/num2)
# Output : 3

Contrairement à la fonction floordiv() du module operator et à l'opérateur de division floor //, l'utilisation de math.floor(num1/num2) garantit que le résultat est un entier. Cette méthode rend le code plus lisible et élimine l'étape de conversion de type.

import math
num1 = 18.0
num2 = 5
math.floor(num1/num2)
# Output : 3

Exemples de division par le sol en Python

Terminons notre discussion par un exemple pratique : Recherche binaire. ✅

📑 La recherche binaire est un algorithme de recherche efficace qui vous permet de rechercher un élément cible dans des tableaux triés en O(log n) temps, où n est la taille du tableau.

Cet algorithme fonctionne en divisant l'intervalle de recherche en deux à chaque étape. Cela se fait selon que le point médian de l'intervalle correspond à la cible (la recherche se termine lorsque la correspondance est trouvée !) ou qu'il est inférieur ou supérieur à la cible. Comme la taille du tableau est réduite de moitié à chaque étape, le point médian ne correspond pas toujours à un entier.

itemlist = [5,7,18,21,34,45]
item = 7

Considérez l'implémentation suivante de l'algorithme de recherche binaire. La fonction binary_search() prend un nombre(item) et une liste(itemlist) et recherche l'occurrence de l'item dans itemlist.

• Si l'élément est trouvé, la fonction renvoie l'indice auquel l'élément apparaît.
• Dans le cas contraire, elle renvoie None.

def binary_search(item, itemlist) :
   # obtenez la taille de la liste
 listsize = len(itemlist) - 1
 # commencez aux deux extrémités de la liste
 lowerIdx = 0
 upperIdx = listsize

 while lowerIdx <= upperIdx :
       # calculez le point central
 # utilisez la division normale au lieu de la division par le sol
 midPt = (lowerIdx upperIdx)/ 2 

 # si l'élément est trouvé, renvoyez l'index
 si itemlist[midPt] == élément :
           return midPt
 # sinon, obtenez le point médian suivant
 if item > itemlist[midPt] :
 lowerIdx = midPt 1
 else :
 upperIdx = midPt - 1

 if lowerIdx > upperIdx :
 return None

Cette implémentation est fonctionnellement correcte, à l'exception du fait que nous n'avons pas tenu compte du fait que la valeur de midPt n'est pas un entier au fur et à mesure que la recherche progresse.

binary_search(item,itemlist)

Si nous appelons la fonction, nous rencontrons une TypeError indiquant que les indices de la liste doivent être des entiers ou des tranches, et non des flottants.

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-3-a5f12ebc3145> in <module>
---->
 1 binary_search(item,itemlist)

<ipython-input-2-524ef6900b1f> in binary_search(item, itemlist)
 12 
 13 # si l'élément est trouvé, renvoyer l'index
--->
 14 if itemlist[midPt] == item :
    15 return midPt
 16 # sinon, on obtient le point médian suivant

TypeError : list indices must be integers or slices, not float

Nous modifions la définition de la fonction pour utiliser l'opérateur de division floor :

def binary_search(item, itemlist) :
   # obtenir la taille de la liste
 listsize = len(itemlist) - 1
 # commencer aux deux extrémités de la liste
 lowerIdx = 0
 upperIdx = listsize

 while lowerIdx <= upperIdx :
       # calculez le point central
 # utilisez la division par le sol
 midPt = (lowerIdx upperIdx)// 2 

 # si l'élément est trouvé, renvoyez l'index
 si itemlist[midPt] == élément :
           return midPt
 # sinon, obtenez le point médian suivant
 if item > itemlist[midPt] :
 lowerIdx = midPt 1
 else :
 upperIdx = midPt - 1

 if lowerIdx > upperIdx :
 return None

La fonction renvoie l'indice auquel l'élément 7 a été trouvé, c'est-à-dire l'indice un.

binary_search(item,itemlist)
# Sortie : 1

Conclusion

J'espère que ce tutoriel vous a aidé à comprendre comment effectuer une division par étage en Python. Voici un résumé des différentes méthodes que vous avez apprises :

• En Python, a opérateur b effectue l'opération définie par l'opérateur avec a et b comme opérandes et renvoie le résultat de l'opération.
• Vous pouvez utiliser l'opérateur de division de Python // ; a//b renvoie le quotient de l'opération de division a/b.
• Vous pouvez également utiliser la fonction équivalente floordiv() définie dans le module operator de Python avec la syntaxe : operator.floordiv(a,b) pour obtenir le résultat de a//b.
• Toutes les méthodes ci-dessus renvoient au quotient, mais le type de données peut être un float ou un int en fonction des valeurs de a et b. Vous devrez donc convertir la valeur de retour en un entier.
• La fonction floor() du module math de Python peut également être utilisée pour effectuer une division par le sol : math.floor(a,b) est équivalent à a//b et renvoie un entier. Lorsque vous souhaitez que le résultat soit un entier, pensez à utiliser la fonction floor du module mathématique.

Découvrez ensuite comment utiliser defaultdict en Python. 👩🏽‍💻