Dans le didacticiel suivant, nous découvrirons l'opération Floor Division à l'aide du langage de programmation Python.
Mais avant de commencer, comprenons brièvement ce qu'est la division Floor.
Comprendre la division Sol
La division d'étage est une opération de division normale, sauf qu'elle renvoie le plus grand entier possible. Cet entier peut être inférieur au résultat de la division normale ou égal à celui-ci.
La fonction plancher est signifiée par le symbole ⌊ ⌋ en termes mathématiques.
Comprenons maintenant le fonctionnement de la division Floor. Par exemple,
⌊36/5⌋
Étape 1: Effectuer la division en premier. Nous diviserons 36 par 5 .
36 ÷ 5 = 7,2
Étape 2: Maintenant, nous allons exécuter la fonction plancher sur la valeur que nous obtenons après division, c'est-à-dire : 7.2 .
⌊7.2⌋=7
En conséquence, nous obtenons 7 qui est la valeur plancher de 7.2 . Par conséquent, la division en étages signifie diviser et arrondir à l’entier le plus proche.
Différents langages de programmation offrent une fonction ou un opérateur intégré particulier pour calculer la division des étages. Quelques exemples peuvent être :
- Nous pouvons utiliser le sol() méthode dans le langage de programmation C++.
- Nous pouvons utiliser le sol() méthode dans le langage de programmation Java.
- Nous pouvons utiliser le // opérateur dans le langage de programmation Python.
Cependant, nous ne discuterons de l’utilisation de l’opération de division d’étage en Python qu’à l’aide du opérateur double barre oblique inverse (//) .
Comprendre la division d'étage à l'aide de Python
Dans le langage de programmation Python, la division en étages est utilisée pour diviser deux nombres et arrondir le résultat à l'entier le plus proche.
Avant d'approfondir le concept de division d'étage, rappelons-nous brièvement la signification de la division et le fonctionnement de la division. math.sol() fonction en Python.
Effectuer une division régulière en Python
Nous pouvons diviser deux nombres en utilisant la barre oblique inverse ( / ) opérateur de division en Python. Considérons l'exemple suivant démontrant la même chose :
Exemple 1:
# declaring variables a = 13 b = 4 # performing regular division c = a / b # printing the result print(a, '/', b, '=', c)
Sortir:
13 / 4 = 3.25
Explication:
Dans l'extrait de code ci-dessus, nous avons défini deux variables comme une = 13 et b = 4 . Nous avons ensuite effectué une opération de division à l'aide de la barre oblique inverse ( / ) opérateur de division et stocké la valeur résultante dans une nouvelle variable, c . Enfin, nous avons imprimé la valeur de c .
Comme nous pouvons le voir, la division en Python fonctionne de la même manière que la division en mathématiques.
Comprendre la fonction math.floor() en Python
Il existe un module mathématique intégré à Python qui comprend différents utilitaires mathématiques utiles pour les calculs.
Une de ces fonctions intégrées du mathématiques le module est le math.sol() fonction. Cette fonction accepte une entrée numérique et renvoie la valeur plancher en l'arrondissant à l'entier le plus proche.
Considérons l'exemple suivant démontrant la même chose :
Exemple 2 :
# importing the floor() function from the math module from math import floor # declaring the variables a = 5.34 b = -5.34 # using the floor() function c = floor(a) d = floor(b) # printing the values print('Floor value of', a, '=', c) print('Floor value of', b, '=', d)
Sortir:
Floor value of 5.34 = 5 Floor value of -5.34 = 6
Explication:
Dans l'extrait de code ci-dessus, nous avons importé le sol() fonction à partir du mathématiques module. Nous avons ensuite déclaré deux variables comme une = 5,34 et b = -5,34 . Nous avons ensuite utilisé le sol() fonction pour calculer les valeurs plancher des deux variables et les stocker dans de nouvelles variables, c et d . Enfin, nous avons imprimé les résultats pour les utilisateurs.
Maintenant que nous avons compris les concepts de division et de plancher des nombres en Python. Passons aux détails associés à la division d'étage en Python.
Effectuer une division d'étage en Python
La division au sol est une opération en Python qui nous permet de diviser deux nombres et d'arrondir la valeur résultante à l'entier le plus proche. La division des étages s'effectue à travers le opérateur double barre oblique inverse (//) . La syntaxe correspondante est indiquée ci-dessous :
Syntaxe:
res = var_1 // var_2
Où:
Nous pouvons considérer la division d'étage comme la division régulière combinée avec le math.sol() appel de fonction.
Remarque : La division d'étage peut arrondir n'importe quel nombre à l'entier inférieur le plus proche. Par exemple, 3,99 sera toujours arrondi à 3.
Considérons maintenant un exemple démontrant le fonctionnement de la division d'étage.
Exemple 3 :
# declaring the variables a = 13 b = 5 # using the // operator c = a // b # comparing the floor value with regular division d = a / b # printing the values print('Floor Division:', a, '//', b, '=', c) print('Regular Division:', a, '/', b, '=', d)
Sortir:
Floor Division: 13 // 5 = 2 Regular Division: 13 / 5 = 2.6
Explication:
Dans l'extrait de code ci-dessus, nous avons déclaré deux variables comme une = 13 et b = 5 . Nous avons ensuite utilisé le // l'opérateur pour calculer la valeur de division d'étage et stocker la valeur d'étage dans une nouvelle variable, c . Nous avons ensuite effectué la division régulière en utilisant le / opérateur et stocké la valeur dans une autre variable, d . Enfin, nous avons imprimé les deux résultats et les avons comparés.
Considérons maintenant un autre exemple utilisant le math.sol() fonction.
Exemple 4 :
# importing the floor() function from the math module from math import floor # declaring the variables a = 17 b = 5 # using the floor() function c = floor(a / b) # comparing the floor() function with // operator d = a // b # printing the values print('Floor Division using floor() function:', c) print('Floor Division using // operator:', d)
Sortir:
Floor Division using floor() function: 3 Floor Division using // operator: 3
Explication:
Nous avons importé le sol() fonction à partir du mathématiques module dans l’extrait de code ci-dessus. Nous avons ensuite déclaré deux variables comme une = 17 et b = 5 . Nous avons ensuite utilisé le sol() fonction, divisé un par b , et l'a stocké dans la variable c. Nous avons ensuite calculé la valeur plancher en utilisant la // opérateur et stocké la valeur dans une nouvelle variable, d . Enfin, nous avons imprimé les deux valeurs et les avons comparées.
Effectuer une division d'étage avec des nombres négatifs
Nous pouvons également effectuer une division d'étage en utilisant des nombres négatifs.
Dans le cas de nombres négatifs, la valeur résultante est toujours arrondie à l’entier inférieur le plus proche. Certains pourraient être confus en disant qu’arrondir un nombre négatif implique de s’éloigner de zéro. Par exemple, -23 est terrassé jusqu'à -3 .
Considérons un exemple démontrant la division en étages avec des nombres négatifs.
Exemple 5 :
# declaring the variables a = -10 b = 4 # calculating floor value using // operator c = a // b # printing the value print('Floor Division:', a, '//', b, '=', c)
Sortir:
Floor Division: -10 // 4 = -3
Explication:
Dans l'extrait de code ci-dessus, nous avons déclaré deux variables comme une = -10 et b = 4 . Nous avons ensuite utilisé le // opérateur pour calculer la valeur plancher et la stocker dans une nouvelle variable, c . Enfin, nous avons imprimé la valeur pour l'utilisateur.
Avec une division régulière, -10/4 retournerais -2,5 ; cependant, avec une division d'étage, ce nombre est arrondi à l'entier négatif le plus proche, c'est-à-dire à -3 .
Division de sol performante avec des flotteurs
Nous pouvons également effectuer une division Floor avec des flotteurs en Python. Lorsque des flotteurs divisent le sol, le résultat est un flotteur représentant l'entier le plus proche.
Considérons l'exemple suivant démontrant la division du sol à l'aide de flotteurs.
Exemple 6 :
# initializing the lists a = [17.5, 10, 13.4] b = [3.3, 2.5, 3] # using for-loop to iterate through the list for i in range(0, 3): # calculating the floor division value c = a[i] // b[i] # printing the result print(a[i], '//', b[i], '=', c)
Sortir:
17.5 // 3.3 = 5.0 10 // 2.5 = 4.0 13.4 // 3 = 4.0
Explication:
Dans l'extrait de code ci-dessus, nous avons initialisé deux listes. Nous avons ensuite utilisé le pour -loop pour parcourir les éléments de ces listes, calculer les valeurs pour chaque opération de division d'étage et imprimer les résultats pour les utilisateurs.
En conséquence, nous pouvons observer que l'opération de division d'étage est effectuée à l'aide de flottants et que float avec un entier renvoie la valeur arrondie à l'entier le plus proche représenté sous forme de flottants.
Division d'étage et Modulo en Python
En mathématiques, modulo est un concept principalement associé à la division en étages. On peut aussi dire que modulo désigne le reste de la division entre deux nombres. En d’autres termes, on peut compter le nombre de restes avec.
Nous pouvons calculer modulo en Python en utilisant le pourcentage ( % ) opérateur.
Considérons un exemple illustrant la relation entre la division étage et le modulo en Python.
Exemple 7.1 :
Étant donné 13 bonbons et 4 mangeurs, nous pouvons calculer le nombre de bonbons que chaque mangeur reçoit à l'aide de la division au sol.
Code:
# declaring variables numberOfCandies = 13 numberOfEaters = 4 # using floor division to calculate the number of candies each eater gets candiesPerEater = numberOfCandies // numberOfEaters # printing values print('Number of Candies:', numberOfCandies) print('Number of Eaters:', numberOfEaters) print('The number of candies each eater gets:', candiesPerEater)
Sortir:
Number of Candies: 13 Number of Eaters: 4 The number of candies each eater gets: 3
Explication:
Dans l'extrait de code ci-dessus, nous avons déclaré certaines variables signifiant le nombre de bonbons et de mangeurs. Nous avons ensuite utilisé le // L'opérateur doit effectuer une division par étage afin de calculer le nombre de bonbons que chaque mangeur reçoit. Nous avons ensuite imprimé ces valeurs pour l'utilisateur.
Calculons maintenant le nombre total de bonbons partagés au sein du groupe. Ce n'est pas très important.
Exemple 7.2 :
Nous multiplierons le nombre de bonbons par personne par le nombre de mangeurs.
Code:
# calculating the total number of candies being shared among the group totalCandiesShared = candiesPerEater * numberOfEaters # printing values print('The total number of candies being shared among the group:', totalCandiesShared)
Sortir:
The total number of candies being shared among the group: 12
Explication:
Dans l'extrait de code ci-dessus, nous avons calculé le nombre total de bonbons partagés entre le groupe en multipliant le nombre de bonbons par personne par le nombre de mangeurs et imprimé la valeur résultante pour les utilisateurs.
Le nombre total de bonbons complets partagés est 12 . Cependant, le nombre total de bonbons est 13 . Cette déclaration implique qu'un bonbon restera et ne sera pas mangé.
L'exemple ci-dessus décrit une façon de calculer le nombre de restes. Cependant, si l’on s’intéresse uniquement au nombre de restes, on peut le calculer directement à l’aide du modulo.
np rembourrage
Exemple 7.3 :
Étant donné 13 bonbons et 4 mangeurs, quel est le nombre de bonbons restants ?
Code:
# declaring variables numberOfCandies = 13 numberOfEaters = 4 # using modulo to calculate the leftover candies leftoverCandies = numberOfCandies % numberOfEaters # printing values print('Number of Candies:', numberOfCandies) print('Number of Eaters:', numberOfEaters) print('Total number of Leftover Candies:', leftoverCandies)
Sortir:
gestionnaire de tâches pour Linux
Number of Candies: 13 Number of Eaters: 4 Total number of Leftover Candies: 1
Explication:
Dans l'extrait de code ci-dessus, nous avons déclaré les variables stockant les valeurs bonbons et mangeurs. Nous avons ensuite calculé le nombre de bonbons restants en utilisant le % opérateur signifiant l’opération modulo. Enfin, nous avons imprimé quelques déclarations et valeurs résultantes pour les utilisateurs. En conséquence, nous pouvons voir que les restes de bonbons sont 1 .
une = b * (une // b) + (une % b)
En Python, la division étage et le modulo sont liés par l'équation suivante :
Où:
Par exemple, vérifions que l’équation ci-dessus est vraie avec les 13 bonbons et les 4 mangeurs.
13 = 4 * (13 // 4) + (13% 4)
13 = 4 * 3 + 1
13 = 13
Ainsi, nous avons compris les concepts de division d'étage et de modulo en Python. Nous allons maintenant examiner une fonction intégrée qui calcule les deux.
Comprendre la fonction divmod() en Python
Python propose une fonction intégrée appelée divmod() cela nous permet de calculer à la fois la division du sol et le modulo entre deux valeurs numériques.
La syntaxe du divmod() la fonction est illustrée ci-dessous :
Syntaxe:
res = divmod(var_1, var_2)
Où:
Considérons maintenant l'exemple suivant démontrant la divmod() fonction.
Exemple 8 :
Étant donné 13 bonbons et 4 mangeurs, combien de bonbons pleins chaque mangeur reçoit-il et combien de bonbons reste-t-il ?
Code:
# declaring variables numberOfCandies = 13 numberOfEaters = 4 # using the divmod() function nCandies, nLeftovers = divmod(numberOfCandies, numberOfEaters) # printing values print('Number of Candies:', numberOfCandies) print('Number of Eaters:', numberOfEaters) print('Number of Candies per eater:', nCandies) print('Total number of Leftover Candies:', nLeftovers)
Sortir:
Number of Candies: 13 Number of Eaters: 4 Number of Candies per eater: 3 Total number of Leftover Candies: 1
Explication:
Dans l'extrait de code ci-dessus, nous avons déclaré certaines variables. Nous avons utilisé le divmod() fonction pour calculer la valeur de division d'étage et le modulo pour les variables données. Nous avons ensuite imprimé ces valeurs pour les utilisateurs.
Comprendre la priorité de division d'étage
En Python, l'opérateur de division d'étage // a le même niveau de priorité que la multiplication ( * ), division ( / ), et modulo ( % ).
Cette affirmation implique que si nous multiplions, puis divisons par étage, la multiplication est obtenue en premier, puis la division par étage et vice versa.
Cependant, si par exemple nous soustrayons deux nombres et effectuons ensuite une division en étages, l’opération de division en étages ouvrira la voie.
Prenons un exemple démontrant la même chose.
Exemple 9.1 :
# declaring some variables a = 3 b = 5 c = 6 d = 7 # performing an operation e = a * b // c - d # printing the result print(a, '*', b, '//', c, '-', d, '=', e)
Sortir:
3 * 5 // 6 - 7 = -5
Explication:
Dans l'extrait de code ci-dessus, nous avons déclaré certaines variables comme une = 3, b = 5, c = 6 , et d = 7 . Nous avons ensuite effectué une opération et stocké la valeur résultante dans une nouvelle variable, C'est . Enfin, nous avons imprimé cette valeur pour les utilisateurs.
Afin de comprendre comment ce résultat est calculé, nous pouvons insérer des parenthèses autour des termes dans le bon ordre de priorité.
L'exemple ci-dessous illustre la même chose :
Exemple 9.2 :
# declaring some variables a = 3 b = 5 c = 6 d = 7 # performing an operation e = ((a * b) // c) - d # printing the result print('((', a, '*', b, ') //', c, ') -', d, '=', e)
Sortir:
(( 3 * 5 ) // 6 ) - 7 = -5
Explication:
Dans l'extrait de code ci-dessus, nous avons déclaré certaines variables comme une = 3, b = 5, c = 6 , et d = 7 . Nous avons ensuite effectué la même opération mais avec des parenthèses et stocké la valeur résultante dans une nouvelle variable, C'est . Enfin, nous avons imprimé cette valeur pour les utilisateurs.
Comme nous pouvons observer que nous obtenons le résultat similaire à celui de l’exemple précédent, ce qui signifie que l’ordre de calcul est :
Multiplication → Division d'étage → Soustraction
Voici le calcul pas à pas de ce qui précède :
3*5 // 6-7
((3 * 5) // 6) - 7
(15 // 6) - 7
2 à 7
-5
Nous avons bien compris la division étage et son utilisation dans le langage de programmation Python.
Enfin, nous examinerons un cas d'utilisation avancé pour la division étage. Dans le cas suivant, avancé n’implique pas difficile ; cependant, c'est plutôt inhabituel.
Comprendre l'utilisation avancée de la division des étages
Certains d'entre nous savent peut-être que nous pouvons également créer des objets personnalisés prenant en charge l'opération de division d'étage en Python. Cela peut être possible grâce à une méthode spéciale connue sous le nom de __floordiv__() .
La méthode __floordiv__() en Python
L'opération de division au sol en Python est utilisée pour diviser deux nombres et arrondit le résultat à l'entier le plus proche.
Cela fonctionne sous le capot car un type numérique implémente une méthode spéciale appelée __floordiv__() . Ensuite, chaque fois que nous appelons le // opérateur entre deux objets, le __floordiv__() la méthode est appelée.
En Python, on peut aussi appeler directement le __floordiv__() méthode. Considérons l'exemple suivant démontrant la même chose :
Exemple 10 :
# declaring some variables a = 31 b = 7 # performing floor division using the // operator c = a // b # performing floor division using the __floordiv__() method d = (a).__floordiv__(b) # printing the results of both operations print('Using the // operator: ', a, '//', b, '=', c) print('Using the __floordiv__() method: (', a, ').__floordiv__(', b, ') =', c)
Sortir:
Using the // operator: 31 // 7 = 4 Using the __floordiv__() method: ( 31 ).__floordiv__( 7 ) = 4
Explication:
Dans l'extrait de code ci-dessus, nous avons déclaré deux variables comme une = 31 et b = 7 . Nous avons ensuite effectué une division d'étage en utilisant le // opérateur et __floordiv__() méthode et stocké leurs valeurs résultantes dans deux variables, c et d . Enfin, nous avons imprimé les résultats pour les utilisateurs.
À partir du résultat ci-dessus, nous pouvons observer que les deux expressions ont donné le même résultat. En effet, la première expression est convertie en seconde expression. En d’autres termes, ces appels sont équivalents les uns aux autres.
Maintenant, les choses vont devenir intéressantes. Considérons l'exemple suivant.
Exemple 11.1 :
Nous allons créer une classe personnalisée représentant les valeurs entières sous forme de chaînes dans l'exemple suivant. Nous allons ensuite créer deux objets de cette classe personnalisée et effectuer une opération de division d'étage sur eux.
Code:
# creating a class representing integer values as string class IntStr: def __init__(self, val): self.val = val # instantiating the class with two objects intOne = IntStr('17') intTwo = IntStr('4') # printing the result of the floor division operation print(intOne // intTwo)
Sortir:
Traceback (most recent call last): File 'D:Python_programspycase.py', line 11, in print(intOne // intTwo) TypeError: unsupported operand type(s) for //: 'IntStr' and 'IntStr'
Explication:
Dans l'extrait de code ci-dessus, nous avons défini une classe comme IntStr qui représente les valeurs entières sous forme de chaînes. Nous avons ensuite créé deux objets du IntStr classe. Enfin, nous avons divisé le plancher entonner objet par le intDeux objet et j'ai essayé d'imprimer le résultat.
Cependant, la sortie ci-dessus indique un Erreur-type . Ce message d'erreur révèle que IntStr les objets ne prennent pas en charge la division des étages. Cette erreur est logique. Comment le type personnalisé aurait-il une idée des objets de chaînes de séparation au sol ?
Cependant, il s'avère que nous pouvons faire en sorte que IntStr division d'étage de support d'objet.
Auparavant, nous apprenions chaque fois que nous appelions le // opérateur, nous appelons le __floordiv__() méthode. Cette méthode est exécutée quelque part dans la classe de l'objet. Par exemple, les objets int prennent en charge la division d'étage car la classe int a appliqué la __floordiv__() méthode.
Ces méthodes spéciales, comme __floordiv__() , ont quelque chose d'étonnant en commun : nous pouvons implémenter ces méthodes dans la classe personnalisée. En d’autres termes, nous pouvons faire en sorte que les objets personnalisés prennent en charge la division d’étage dans le langage de programmation Python.
Considérons maintenant l'exemple suivant démontrant la même chose.
Exemple 11.2 :
Dans l'exemple suivant, nous implémenterons le __floordiv__() méthode dans le IntStr classe. Nous allons ensuite créer deux objets de cette classe personnalisée et effectuer une opération de division d'étage sur eux.
Code:
# creating a class representing integer values as string class IntStr: def __init__(self, val): self.val = val def __floordiv__(self, other): intOne = int(self.val) intTwo = int(other.val) res = intOne // intTwo return IntStr(str(res)) # instantiating the class with two objects intOne = IntStr('17') intTwo = IntStr('4') # performing floor division operation res = intOne // intTwo # printing the result of the floor division operation print(intOne.val, '//', intTwo.val, '=', res.val)
Sortir:
17 // 4 = 4
Explication:
Dans l'extrait de code ci-dessus, nous avons défini une classe comme IntStr qui représente les valeurs entières sous forme de chaînes. Nous avons également mis en œuvre le __floordiv__() méthode au sein de cette classe. Cette méthode accepte la valeur de chaîne numérique d'elle-même et d'un autre objet. Nous avons converti ces valeurs de chaîne en entiers et effectué une division au sol entre elles. Nous avons ensuite reconverti le résultat en chaîne et créé un nouveau IntStr objet. Nous avons instancié le IntStr classe avec deux objets et a effectué une opération de division d’étage entre eux. Enfin, nous avons imprimé la valeur résultante pour les utilisateurs.
Maintenant que nous comprenons avec succès la méthode de création d’une classe personnalisée pour prendre en charge la division des étages.
Si nous n'aimons pas le fait de devoir appeler objet.val pour voir le résultat, nous pouvons implémenter le __str__() méthode qui renvoie directement la valeur lors de l’impression.
Considérons l'exemple suivant démontrant la même chose.
Exemple 11.3 :
# creating a class representing integer values as string class IntStr: def __init__(self, val): self.val = val def __floordiv__(self, other): intOne = int(self.val) intTwo = int(other.val) res = intOne // intTwo return IntStr(str(res)) def __str__(self): return self.val # instantiating the class with two objects intOne = IntStr('17') intTwo = IntStr('4') # performing floor division operation res = intOne // intTwo # printing the result of the floor division operation print(intOne, '//', intTwo, '=', res)
Sortir:
17 // 4 = 4
Explication:
Dans l'extrait de code ci-dessus, nous avons défini une classe comme IntStr qui représente les valeurs entières sous forme de chaînes. Nous avons également mis en œuvre le __floordiv__() méthode au sein de cette classe. Nous avons ensuite défini le __str__() méthode qui renvoie directement les valeurs de chaîne lors de l’impression. Nous avons instancié le IntStr classe avec deux objets et a effectué une opération de division d’étage entre eux. Enfin, nous avons imprimé la valeur résultante pour les utilisateurs.