In de volgende tutorial leren we over de Floor Division-bewerking met behulp van de programmeertaal Python.

Maar laten we, voordat we beginnen, kort begrijpen wat vloerverdeling is.

De vloerverdeling begrijpen

Vloerdeling is een normale delingsbewerking, behalve dat deze het grootst mogelijke gehele getal retourneert. Dit gehele getal kan kleiner zijn dan de normale delingsuitvoer, of gelijk daaraan.

De vloerfunctie wordt in wiskundige termen aangeduid met het ⌊ ⌋ symbool.

Laten we nu de werking van de vloerverdelingsoperatie begrijpen. Bijvoorbeeld,

⌊36/5⌋

Stap 1: Eerst de deling uitvoeren. Wij zullen verdelen 36 door 5 .

36 ÷ 5 = 7,2

Stap 2: Nu zullen we de vloerfunctie uitvoeren op de waarde die we krijgen na deling, d.w.z. 7.2 .

⌊7,2⌋=7

Als gevolg hiervan krijgen we 7 dat is de vloerwaarde van 7.2 . Vloerdeling betekent dus delen en naar beneden afronden op het dichtstbijzijnde gehele getal.

Verschillende programmeertalen bieden een bepaalde ingebouwde functie of operator om de vloerindeling te berekenen. Enkele voorbeelden kunnen zijn:

1. Wij kunnen gebruik maken van de vloer() methode in de programmeertaal C++.
2. Wij kunnen gebruik maken van de vloer() methode in de programmeertaal Java.
3. Wij kunnen gebruik maken van de // operator in de programmeertaal Python.

We zullen echter alleen het gebruik van de vloerverdelingsbewerking in Python bespreken met behulp van de operator met dubbele backslash (//). .

Vloerverdeling begrijpen met Python

In de programmeertaal Python wordt vloerdeling gebruikt om twee getallen te delen en wordt de uitkomst naar beneden afgerond op het dichtstbijzijnde gehele getal.

Voordat we dieper ingaan op het concept van vloerverdeling, moeten we onszelf kort herinneren aan de betekenis van verdeling en de werking van de vloerverdeling wiskunde.vloer() functie in Python.

Reguliere verdeling uitvoeren in Python

We kunnen twee getallen delen met behulp van de backslash ( / ) divisie-operator in Python. Laten we het volgende voorbeeld bekijken dat hetzelfde aantoont:

Voorbeeld 1:

 # declaring variables a = 13 b = 4 # performing regular division c = a / b # printing the result print(a, '/', b, '=', c) 

Uitgang:

 13 / 4 = 3.25 

Uitleg:

In het bovenstaande codefragment hebben we twee variabelen gedefinieerd als een = 13 En b = 4 . Vervolgens hebben we een delingsbewerking uitgevoerd met behulp van de backslash ( / ) delingsoperator en de resulterende waarde opgeslagen in een nieuwe variabele, C . Eindelijk hebben we de waarde van afgedrukt C .

Zoals we kunnen zien werkt delen in Python op dezelfde manier als delen in de wiskunde.

Inzicht in de functie math.floor() in Python

Er is een ingebouwde wiskundemodule in Python die bestaat uit verschillende nuttige wiskundige hulpprogramma's voor berekeningen.

Een dergelijke ingebouwde functie van de wiskunde module is de wiskunde.vloer() functie. Deze functie accepteert een numerieke invoer en retourneert de minimumwaarde door deze naar beneden af ​​te ronden op het dichtstbijzijnde gehele getal.

Laten we het volgende voorbeeld bekijken dat hetzelfde aantoont:

Voorbeeld 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) 

Uitgang:

 Floor value of 5.34 = 5 Floor value of -5.34 = 6 

Uitleg:

In het bovenstaande codefragment hebben we de vloer() functie uit de wiskunde module. Vervolgens hebben we twee variabelen gedeclareerd als a = 5,34 En b = -5,34 . Wij hebben toen gebruik gemaakt van de vloer() functie om de vloerwaarden van beide variabelen te berekenen en deze op te slaan in nieuwe variabelen, C En D . Eindelijk hebben we de resultaten voor de gebruikers afgedrukt.

Nu we de concepten van delen en vloergetallen in Python hebben begrepen. Laten we eens kijken naar de details die verband houden met de vloerverdeling in Python.

Vloerverdeling uitvoeren in Python

Vloerdeling is een bewerking in Python waarmee we twee getallen kunnen delen en de resulterende waarde naar beneden afronden op het dichtstbijzijnde gehele getal. De vloerverdeling vindt plaats via de operator met dubbele backslash (//). . De syntaxis hiervoor wordt hieronder weergegeven:

Syntaxis:

 res = var_1 // var_2 

Waar:

resis de resulterende waarde van de vloerverdelingwas_1is het dividendwas_2is de deler

We kunnen de vloerindeling zien als de reguliere indeling gecombineerd met de wiskunde.vloer() functie oproep.

mockito wanneer dan ook

Opmerking: bij de vloerverdeling kan elk getal naar beneden worden afgerond op het dichtstbijzijnde gehele getal. Zo wordt 3,99 nog steeds naar beneden afgerond naar 3.

Laten we nu een voorbeeld bekijken dat de werking van vloerverdeling demonstreert.

Voorbeeld 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) 

Uitgang:

 Floor Division: 13 // 5 = 2 Regular Division: 13 / 5 = 2.6 

Uitleg:

In het bovenstaande codefragment hebben we twee variabelen gedeclareerd als een = 13 En b = 5 . Wij hebben toen gebruik gemaakt van de // operator om de vloerverdelingswaarde te berekenen en de vloerwaarde op te slaan in een nieuwe variabele, C . Vervolgens hebben we de reguliere deling uitgevoerd met behulp van de / operator en sloeg de waarde op in een andere variabele, D . Eindelijk hebben we beide resultaten afgedrukt en vergeleken.

Laten we nu een ander voorbeeld bekijken met behulp van de wiskunde.vloer() functie.

Voorbeeld 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) 

Uitgang:

 Floor Division using floor() function: 3 Floor Division using // operator: 3 

Uitleg:

Wij hebben de vloer() functie uit de wiskunde module in het bovenstaande codefragment. Vervolgens hebben we twee variabelen gedeclareerd als een = 17 En b = 5 . Wij hebben toen gebruik gemaakt van de vloer() functie, verdeeld A door B , en opgeslagen in variabele c. Vervolgens hebben we de vloerwaarde berekend met behulp van de // operator en sloeg de waarde op in een nieuwe variabele, D . Eindelijk hebben we beide waarden afgedrukt en vergeleken.

Vloerverdeling uitvoeren met negatieve getallen

We kunnen ook een verdiepingsverdeling uitvoeren met behulp van negatieve getallen.

In het geval van negatieve getallen wordt de resulterende waarde nog steeds naar beneden afgerond op het dichtstbijzijnde gehele getal. Sommigen raken misschien in de war doordat het naar beneden afronden van een negatief getal impliceert dat je van nul afgaat. Bijvoorbeeld, -23 is verdiept tot -3 .

Laten we een voorbeeld bekijken waarin de vloerverdeling met negatieve getallen wordt gedemonstreerd.

Voorbeeld 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) 

Uitgang:

 Floor Division: -10 // 4 = -3 

Uitleg:

In het bovenstaande codefragment hebben we twee variabelen gedeclareerd als a = -10 En b = 4 . Wij hebben toen gebruik gemaakt van de // operator om de vloerwaarde te berekenen en deze op te slaan in een nieuwe variabele, C . Eindelijk hebben we de waarde voor de gebruiker afgedrukt.

Met een regelmatige verdeling -10/4 zou terugbrengen -2,5 ; Bij een vloerverdeling wordt dit getal echter naar beneden afgerond op het dichtstbijzijnde negatieve gehele getal, d.w.z. op -3 .

Vloerverdeling uitvoeren met drijvers

Ook kunnen wij Vloerverdeling met drijvers in Python uitvoeren. Wanneer vloerverdeling zweeft, is de uitkomst een float die het dichtstbijzijnde gehele getal vertegenwoordigt.

Laten we het volgende voorbeeld bekijken waarin de vloerverdeling wordt gedemonstreerd met behulp van drijvers.

Voorbeeld 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) 

Uitgang:

 17.5 // 3.3 = 5.0 10 // 2.5 = 4.0 13.4 // 3 = 4.0 

Uitleg:

In het bovenstaande codefragment hebben we twee lijsten geïnitialiseerd. Wij hebben toen gebruik gemaakt van de voor -loop om de elementen van deze lijsten te doorlopen, de waarden voor elke verdiepingsindeling te berekenen en de resultaten voor de gebruikers af te drukken.

Als gevolg hiervan kunnen we zien dat de vloerdelingsbewerking wordt uitgevoerd met behulp van floats en float met integer de waarde retourneert, naar beneden afgerond op het dichtstbijzijnde gehele getal dat wordt weergegeven als de floats.

Vloerindeling en modulo in Python

In de wiskunde is modulo een concept dat voornamelijk wordt geassocieerd met vloerverdeling. We kunnen ook zeggen dat modulo de rest betekent in de deling tussen twee getallen. Met andere woorden: we kunnen er het aantal restjes mee tellen.

We kunnen modulo in Python berekenen met behulp van het percentage ( % ) exploitant.

Laten we een voorbeeld bekijken dat de relatie illustreert tussen de vloerverdeling en modulo in Python.

Voorbeeld 7.1:

Gegeven 13 snoepjes en 4 eters, kunnen we met behulp van de vloerverdeling berekenen hoeveel snoepjes elke eter krijgt.

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) 

Uitgang:

 Number of Candies: 13 Number of Eaters: 4 The number of candies each eater gets: 3 

Uitleg:

In het bovenstaande codefragment hebben we enkele variabelen gedeclareerd die het aantal snoepjes en eters aangeven. Wij hebben toen gebruik gemaakt van de // operator om vloerverdeling uit te voeren om het aantal snoepjes te berekenen dat elke eter krijgt. Deze waarden hebben wij vervolgens voor de gebruiker afgedrukt.

Laten we nu het totale aantal snoepjes berekenen dat door de groep wordt gedeeld. Dit is niet erg belangrijk.

Voorbeeld 7.2:

We vermenigvuldigen het aantal snoepjes per persoon met het aantal eters.

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) 

Uitgang:

 The total number of candies being shared among the group: 12 

Uitleg:

In het bovenstaande codefragment hebben we het totale aantal snoepjes berekend dat onder de groep wordt gedeeld door het aantal snoepjes per persoon te vermenigvuldigen met het aantal eters en de resulterende waarde voor de gebruikers afgedrukt.

Het totale aantal gedeelde volle snoepjes is 12 . Het totale aantal snoepjes is dat echter wel 13 . Deze verklaring houdt in dat er één snoepje overblijft en niet wordt gegeten.

Het bovenstaande voorbeeld beschrijft een manier om het aantal restjes te berekenen. Als we echter alleen geïnteresseerd zijn in het aantal restjes, kunnen we dit direct berekenen met behulp van modulo.

Voorbeeld 7.3:

Gegeven 13 snoepjes en 4 eters, wat is dan het aantal overgebleven snoepjes?

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) 

Uitgang:

 Number of Candies: 13 Number of Eaters: 4 Total number of Leftover Candies: 1 

Uitleg:

In het bovenstaande codefragment hebben we de variabelen gedeclareerd die de waarde snoepjes en eters opslaan. Vervolgens hebben we het aantal overgebleven snoepjes berekend met behulp van de % operator die de modulo-bewerking aangeeft. Eindelijk hebben we enkele uitspraken en resulterende waarden voor de gebruikers afgedrukt. Als gevolg hiervan kunnen we zien dat het overgebleven snoep is 1 .

a = b * (a // b) + (a % b)

In Python zijn de vloerverdeling en de modulo met elkaar verbonden door de volgende vergelijking:

Waar:

Ais het dividend.Bis de deler.

Laten we bijvoorbeeld verifiëren dat de bovenstaande vergelijking geldt voor de 13 snoepjes en 4 eters.

13 = 4 * (13 // 4) + (13% 4)
13 = 4 * 3 + 1
13 = 13

Zo hebben we de concepten van vloerverdeling en modulo in Python begrepen. Nu zullen we kijken naar een ingebouwde functie die beide berekent.

De divmod()-functie in Python begrijpen

Python biedt een ingebouwde functie genaamd divmod() waarmee we zowel de vloerverdeling als de modulo tussen twee numerieke waarden kunnen berekenen.

De syntaxis voor de divmod() functie wordt hieronder weergegeven:

Syntaxis:

 res = divmod(var_1, var_2) 

Waar:

resis het resultaat als een tupel. Dit tupel heeft het resultaat van de vloerverdeling en de rest wordt gegeven door de modulo.was_1is het dividend.was_2is de deler.

Laten we nu het volgende voorbeeld bekijken dat demonstreert divmod() functie.

Voorbeeld 8:

Gegeven 13 snoepjes en 4 eters, hoeveel volle snoepjes krijgt elke eter, en hoeveel snoepjes zijn er nog over?

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) 

Uitgang:

 Number of Candies: 13 Number of Eaters: 4 Number of Candies per eater: 3 Total number of Leftover Candies: 1 

Uitleg:

In het bovenstaande codefragment hebben we enkele variabelen gedeclareerd. Wij hebben gebruik gemaakt van de divmod() functie om de vloerverdelingswaarde en de modulo voor de gegeven variabelen te berekenen. Deze waarden hebben wij vervolgens voor de gebruikers afgedrukt.

Inzicht in de prioriteit van de vloerindeling

In Python, de vloerverdelingsoperator // heeft hetzelfde prioriteitsniveau als vermenigvuldiging ( * ), divisie ( / ), en modulo( % ).

Deze verklaring houdt in dat als we vermenigvuldigen en vervolgens de vloer delen, eerst de vermenigvuldiging wordt bereikt, en vervolgens de vloerdeling, en omgekeerd.

Als we echter bijvoorbeeld twee getallen aftrekken en vervolgens een vloerverdeling uitvoeren, zal de vloerverdeling de weg vrijmaken.

Laten we een voorbeeld bekijken dat hetzelfde aantoont.

Voorbeeld 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) 

Uitgang:

 3 * 5 // 6 - 7 = -5 

Uitleg:

In het bovenstaande codefragment hebben we enkele variabelen gedeclareerd als a = 3, b = 5, c = 6 , En d=7 . Vervolgens hebben we een bewerking uitgevoerd en de resulterende waarde opgeslagen in een nieuwe variabele, Het is . Eindelijk hebben we deze waarde voor de gebruikers afgedrukt.

Om te begrijpen hoe dit resultaat wordt berekend, kunnen we haakjes rond de termen in de juiste prioriteitsvolgorde plaatsen.

Het onderstaande voorbeeld toont hetzelfde:

Voorbeeld 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) 

Uitgang:

 (( 3 * 5 ) // 6 ) - 7 = -5 

Uitleg:

In het bovenstaande codefragment hebben we enkele variabelen gedeclareerd als a = 3, b = 5, c = 6 , En d=7 . Vervolgens hebben we dezelfde bewerking uitgevoerd, maar dan tussen haakjes, en de resulterende waarde opgeslagen in een nieuwe variabele, Het is . Eindelijk hebben we deze waarde voor de gebruikers afgedrukt.

Zoals we kunnen zien, krijgen we hetzelfde resultaat als uit het vorige voorbeeld, wat betekent dat de volgorde van berekening is:

Vermenigvuldigen → Vloerdeling → Aftrekken

Hier is de stapsgewijze berekening van het bovenstaande:

3 * 5 // 6 - 7
((3 * 5) // 6) - 7
(15 // 6) - 7
2 - 7
-5

We hebben de vloerindeling en het gebruik ervan in de programmeertaal Python goed begrepen.

Ten slotte kijken we naar een geavanceerde use case voor de vloerindeling. In het volgende geval betekent geavanceerd niet hard; het is echter nogal ongebruikelijk.

Inzicht in het geavanceerde gebruik van vloerverdeling

Sommigen van ons zijn zich er misschien van bewust dat we ook aangepaste objecten kunnen maken die de vloerverdeling in Python ondersteunen. Dit kan mogelijk zijn via een speciale methode die bekend staat als __vloerdiv__() .

De __floordiv__() methode in Python

De vloerdelingsbewerking in Python wordt gebruikt om twee getallen te delen en rondt het resultaat naar beneden af ​​op het dichtstbijzijnde gehele getal.

Het werkt onder de motorkap omdat een numeriek type een speciale methode implementeert, genaamd __vloerdiv__() . Vervolgens, telkens wanneer we de // operator tussen twee objecten, de __vloerdiv__() methode wordt aangeroepen.

In Python kunnen we ook rechtstreeks de __vloerdiv__() methode. Laten we het volgende voorbeeld bekijken dat hetzelfde aantoont:

Voorbeeld 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) 

Uitgang:

 Using the // operator: 31 // 7 = 4 Using the __floordiv__() method: ( 31 ).__floordiv__( 7 ) = 4 

Uitleg:

In het bovenstaande codefragment hebben we twee variabelen gedeclareerd als een = 31 En b = 7 . Vervolgens hebben we de vloerindeling uitgevoerd met behulp van de // exploitant en __vloerdiv__() methode en sloeg hun resulterende waarden op in twee variabelen, C En D . Eindelijk hebben we de resultaten voor de gebruikers afgedrukt.

Uit de hierboven getoonde uitvoer kunnen we zien dat beide uitdrukkingen hetzelfde resultaat hebben opgeleverd. Dit komt omdat de eerste expressie wordt omgezet in de tweede expressie. Met andere woorden, deze oproepen zijn gelijkwaardig aan elkaar.

Nu zullen de dingen interessant worden. Laten we het volgende voorbeeld bekijken.

Voorbeeld 11.1:

In het volgende voorbeeld zullen we een aangepaste klasse maken die de gehele waarden als tekenreeksen vertegenwoordigt. Vervolgens maken we twee objecten van deze aangepaste klasse en voeren we daarop een verdiepingsverdeling uit.

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) 

Uitgang:

 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' 

Uitleg:

In het bovenstaande codefragment hebben we een klasse gedefinieerd als IntStr dat vertegenwoordigt de gehele waarden als tekenreeksen. We hebben vervolgens twee objecten van de gemaakt IntStr klas. Eindelijk hebben we de vloer verdeeld intEen bezwaar van de intTwee object en probeerde het resultaat af te drukken.

De bovenstaande uitvoer geeft echter een TypeError . Deze foutmelding laat dat zien IntStr objecten ondersteunen de vloerverdeling niet. Deze fout is logisch. Hoe zou het aangepaste type enig idee hebben van tekenreeksobjecten die de vloer verdelen?

Het blijkt echter dat we de IntStr objectondersteuning vloerverdeling.

Voorheen leerden we wanneer we de // operator, noemen we de __vloerdiv__() methode. Deze methode wordt ergens in de klasse van het object uitgevoerd. Int-objecten ondersteunen bijvoorbeeld vloerverdeling omdat de klasse int de __vloerdiv__() methode.

Deze speciale methoden, zoals __vloerdiv__() , hebben iets verbazingwekkends gemeen: we kunnen deze methoden in de aangepaste klasse implementeren. Met andere woorden, we kunnen ervoor zorgen dat de aangepaste objecten verdiepingsverdeling in de programmeertaal Python ondersteunen.

Laten we nu het volgende voorbeeld bekijken dat hetzelfde aantoont.

Voorbeeld 11.2:

In het volgende voorbeeld implementeren we de __vloerdiv__() methode in de IntStr klas. Vervolgens maken we twee objecten van deze aangepaste klasse en voeren we daarop een verdiepingsverdeling uit.

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) 

Uitgang:

 17 // 4 = 4 

Uitleg:

In het bovenstaande codefragment hebben we een klasse gedefinieerd als IntStr dat vertegenwoordigt de gehele waarden als tekenreeksen. Ook hebben wij de __vloerdiv__() methode binnen deze klasse. Deze methode accepteert de numerieke tekenreekswaarde van zichzelf en een ander object. We hebben deze tekenreekswaarden omgezet in gehele getallen en ertussen een vloerverdeling uitgevoerd. Vervolgens hebben we het resultaat weer omgezet in een string en een nieuwe string gemaakt IntStr voorwerp. Wij hebben de IntStr class met twee objecten en voerde een vloerverdelingsoperatie daartussen uit. Eindelijk hebben we de resulterende waarde voor de gebruikers afgedrukt.

Nu we met succes de methode begrijpen voor het maken van een aangepaste klasse ter ondersteuning van de vloerverdeling.

Als het ons niet bevalt, moeten we bellen object.val om het resultaat te zien, kunnen we de implementeren __str__() methode die de waarde direct retourneert tijdens het afdrukken.

Laten we het volgende voorbeeld bekijken dat hetzelfde aantoont.

Voorbeeld 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) 

Uitgang:

 17 // 4 = 4 

Uitleg:

In het bovenstaande codefragment hebben we een klasse gedefinieerd als IntStr dat vertegenwoordigt de gehele waarden als tekenreeksen. Ook hebben wij de __vloerdiv__() methode binnen deze klasse. Vervolgens hebben we de definitie gedefinieerd __str__() methode die de tekenreekswaarden direct retourneert tijdens het afdrukken. Wij hebben de IntStr class met twee objecten en voerde een vloerverdelingsoperatie daartussen uit. Eindelijk hebben we de resulterende waarde voor de gebruikers afgedrukt.