I det følgende selvstudie lærer vi om Floor Division-operationen ved hjælp af Python-programmeringssproget.

Men før vi går i gang, lad os kort forstå, hvad Floor division er.

Forstå gulvopdelingen

Etagedeling er en normal divisionsoperation, bortset fra at den returnerer det størst mulige heltal. Dette heltal kan enten være mindre end det normale divisionsoutput eller lig med det.

Etagefunktionen er angivet med ⌊ ⌋ symbolet i matematiske termer.

Lad os nu forstå, hvordan Floor divisionen fungerer. For eksempel,

⌊36/5⌋

Trin 1: Udførelse af opdelingen først. Vi vil dele 36 ved 5 .

36 ÷ 5 = 7,2

Trin 2: Nu vil vi udføre gulvfunktionen på den værdi, vi får efter division, dvs. 7.2 .

⌊7,2⌋=7

Som et resultat får vi 7 som er etageværdien af 7.2 . Derfor betyder etageopdeling at dividere og runde ned til nærmeste heltal.

Forskellige programmeringssprog tilbyder en bestemt indbygget funktion eller operatør til at beregne etagedeling. Nogle eksempler kan være:

1. Vi kan bruge etage() metode i programmeringssproget C++.
2. Vi kan bruge etage() metode i programmeringssproget Java.
3. Vi kan bruge // operatør i programmeringssproget Python.

Vi vil dog kun diskutere brugen af ​​etageopdelingsoperationen i Python ved hjælp af dobbelt-omvendt skråstreg (//) operator .

Forstå Floor Division ved hjælp af Python

I programmeringssproget Python bruges etagedeling til at dividere to tal og runder resultatet ned til nærmeste heltal.

Før vi dykker dybere ned i begrebet etageopdeling, lad os kort minde os selv om betydningen af ​​opdeling og virkemåden af math.floor() funktion i Python.

Udførelse af Regular Division i Python

Vi kan dividere to tal ved at bruge skråstreg ( / ) divisionsoperatør i Python. Lad os overveje følgende eksempel, der viser det samme:

Eksempel 1:

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

Produktion:

 13 / 4 = 3.25 

Forklaring:

I ovenstående kodestykke har vi defineret to variable som a = 13 og b = 4 . Vi har derefter udført en divisionsoperation ved hjælp af omvendt skråstreg ( / ) divisionsoperatør og gemte den resulterende værdi i en ny variabel, c . Endelig har vi udskrevet værdien af c .

Som vi kan se, fungerer division i Python på samme måde som division fungerer i matematik.

Forståelse af funktionen math.floor() i Python

Der er et indbygget matematikmodul i Python, der består af forskellige nyttige matematiske hjælpeprogrammer til beregninger.

En sådan indbygget funktion af matematik modul er math.floor() fungere. Denne funktion accepterer et numerisk input og returnerer bundværdien ved at runde den ned til nærmeste heltal.

Lad os overveje følgende eksempel, der viser det samme:

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

Produktion:

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

Forklaring:

I ovenstående kodestykke har vi importeret etage() funktion fra matematik modul. Vi har så erklæret to variable som a = 5,34 og b = -5,34 . Vi har så brugt etage() funktion til at beregne bundværdierne for begge variabler og lagre dem i nye variable, c og d . Endelig har vi udskrevet resultaterne til brugerne.

Nu hvor vi har forstået begreberne opdeling og gulvbelægning i Python. Lad os gå ind på detaljerne forbundet med etageopdelingen i Python.

Udførelse af Floor Division i Python

Etagedeling er en operation i Python, der giver os mulighed for at dividere to tal og runder den resulterende værdi ned til det nærmeste heltal. Etagedelingen sker gennem dobbelt-omvendt skråstreg (//) operator . Syntaksen for det samme er vist nedenfor:

array slicing java

Syntaks:

 res = var_1 // var_2 

Hvor:

reser den resulterende værdi af etageinddelingenvar_1er udbyttetvar_2er divisor

Vi kan tænke på etageopdeling som den almindelige opdeling kombineret med math.floor() funktionskald.

Bemærk: Etageopdelingen kan afrunde ethvert tal ned til nærmeste heltal. For eksempel vil 3,99 stadig blive rundet ned til 3.

Lad os nu overveje et eksempel, der demonstrerer gulvopdelingens virkemåde.

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

Produktion:

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

Forklaring:

I ovenstående kodestykke har vi erklæret to variable som a = 13 og b = 5 . Vi har så brugt // operatør til at beregne etagedelingsværdien og gemte etageværdien i en ny variabel, c . Vi har derefter udført den almindelige opdeling vha / operator og gemte værdien i en anden variabel, d . Endelig har vi udskrevet begge resultater og sammenlignet dem.

Lad os nu overveje et andet eksempel ved at bruge math.floor() fungere.

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

Produktion:

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

Forklaring:

Vi har importeret etage() funktion fra matematik modul i ovenstående kodestykke. Vi har så erklæret to variable som a = 17 og b = 5 . Vi brugte derefter etage() funktion, opdelt -en ved b , og gemte den i variabel c. Vi har derefter beregnet etageværdien ved hjælp af // operator og gemte værdien i en ny variabel, d . Til sidst har vi udskrevet begge værdier og sammenlignet dem.

Udførelse af etageopdeling med negative tal

Vi kan også udføre etageopdeling ved hjælp af negative tal.

I tilfælde af negative tal rundes den resulterende værdi stadig ned til nærmeste heltal. Nogle kan blive forvirrede ved at afrunde et negativt tal, betyder at gå væk fra nul. For eksempel, -23 er gulv ned til -3 .

Lad os overveje et eksempel, der viser etageopdelingen med negative tal.

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

Produktion:

 Floor Division: -10 // 4 = -3 

Forklaring:

I ovenstående kodestykke har vi erklæret to variable som a = -10 og b = 4 . Vi har så brugt // operatør til at beregne bundværdien og gemte den i en ny variabel, c . Endelig har vi udskrevet værdien for brugeren.

Med en regulær opdeling, -10/4 ville vende tilbage -2,5 ; dog med en etagedeling rundes dette tal ned til nærmeste negative heltal, dvs -3 .

Udførelse af gulvopdeling med flydere

Vi kan også udføre Gulvdeling med flydere i Python. Når gulvopdeling flyder, er resultatet en flyder, der repræsenterer det nærmeste heltal.

pandas standardafvigelse

Lad os overveje følgende eksempel, der demonstrerer gulvopdelingen ved hjælp af flydere.

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

Produktion:

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

Forklaring:

I ovenstående kodestykke har vi initialiseret to lister. Vi har så brugt til -loop for at iterere gennem elementerne i disse lister, beregnede værdierne for hver etageopdelingsoperation og udskrev resultaterne for brugerne.

Som et resultat kan vi observere, at etagedelingsoperationen udføres ved hjælp af float, og float med heltal returnerer værdien, der rundes ned til det nærmeste heltal repræsenteret som float.

Floor Division og Modulo i Python

I matematik er modulo et begreb, der hovedsageligt forbindes med etagedeling. Vi kan også sige, at modulo betyder resten i divisionen mellem to tal. Vi kan med andre ord tælle antallet af rester med den.

Vi kan beregne modulo i Python ved hjælp af procenten ( % ) operatør.

Lad os overveje et eksempel, der illustrerer forholdet mellem etageopdelingen og modulo i Python.

Eksempel 7.1:

Givet 13 slik og 4 spisende, kan vi beregne antallet af slik, hver spiser får ved hjælp af etageinddelingen.

Kode:

støbt i sql

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

Produktion:

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

Forklaring:

I ovenstående kodestykke har vi erklæret nogle variabler, der angiver antallet af slik og spisende. Vi har så brugt // operatør til at udføre etagedeling for at beregne antallet af slik, hver spiser får. Vi har derefter udskrevet disse værdier for brugeren.

Lad os nu beregne det samlede antal slik, der deles mellem gruppen. Det er ikke særlig vigtigt.

Eksempel 7.2:

Vi vil gange antallet af slik pr. person med antallet af spisere.

Kode:

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

Produktion:

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

Forklaring:

I ovenstående kodestykke har vi beregnet det samlede antal slik, der deles mellem gruppen, ved at gange antallet af slik pr. person med antallet af spisende og udskrevet den resulterende værdi for brugerne.

Det samlede antal delte bolsjer er 12 . Det samlede antal slik er dog 13 . Denne erklæring indebærer, at en slik vil være tilbage og ikke vil blive spist.

Ovenstående eksempel beskriver en måde at beregne antallet af rester på. Men hvis vi kun er interesseret i antallet af rester, kan vi direkte beregne det ved hjælp af modulo.

Eksempel 7.3:

Givet 13 slik og 4 spisende, hvad er antallet af slikrester?

Kode:

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

Produktion:

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

Forklaring:

I ovenstående kodestykke har vi erklæret de variabler, der lagrer værdien slik og spisere. Vi har så beregnet antallet af rester af slik ved hjælp af % operator, der angiver modulo-operationen. Endelig har vi udskrevet nogle udsagn og resulterende værdier til brugerne. Som et resultat kan vi se, at den resterende slik er 1 .

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

I Python er etageinddelingen og modulo forbundet med følgende ligning:

Hvor:

-ener udbyttet.ber divisor.

Lad os for eksempel kontrollere, at ovenstående ligning gælder for de 13 slik og 4 spisende.

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

Således har vi forstået begreberne etagedeling og modulo i Python. Nu vil vi se på en indbygget funktion, der beregner begge dele.

Forståelse af divmod()-funktionen i Python

Python tilbyder en indbygget funktion kaldet divmod() der giver os mulighed for at beregne både etagedeling og modulo mellem to numeriske værdier.

Syntaksen for divmod() funktion er vist nedenfor:

Syntaks:

 res = divmod(var_1, var_2) 

Hvor:

reser resultatet som en tupel. Denne tupel har etagedelingsresultatet og resten givet af modulo.var_1er udbyttet.var_2er divisor.

Lad os nu overveje følgende eksempel, der demonstrerer divmod() fungere.

Eksempel 8:

Givet 13 slik og 4 spisende, hvor mange fulde slik får hver spiser, og hvor mange slik er der tilbage?

Kode:

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

Produktion:

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

Forklaring:

I ovenstående kodestykke har vi erklæret nogle variabler. Vi har brugt divmod() funktion til at beregne etagedelingsværdien og modulo for de givne variable. Vi har så udskrevet disse værdier til brugerne.

Forstå gulvopdelingens forrang

I Python, etageopdelingsoperatøren // har samme prioritetsniveau som multiplikation ( * ), division ( / ), og modulo ( % ).

Dette udsagn indebærer, at hvis vi multiplicerer og derefter etagedeler, opnås multiplikationen først, og derefter etagedelingen og omvendt.

Men hvis vi for eksempel trækker to tal fra og derefter udfører etagedeling, vil etagedelingsoperationen bane vejen.

Lad os overveje et eksempel, der viser det samme.

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

Produktion:

 3 * 5 // 6 - 7 = -5 

Forklaring:

I ovenstående kodestykke har vi erklæret nogle variabler som a = 3, b = 5, c = 6 , og d = 7 . Vi har derefter udført en operation og gemt den resulterende værdi i en ny variabel, det er . Endelig har vi udskrevet denne værdi for brugerne.

For at forstå, hvordan dette resultat beregnes, kan vi indsætte parenteser omkring vilkårene i den rigtige rækkefølge.

Eksemplet nedenfor viser det samme:

kald javascript-funktion fra html

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

Produktion:

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

Forklaring:

I ovenstående kodestykke har vi erklæret nogle variabler som a = 3, b = 5, c = 6 , og d = 7 . Vi har derefter udført den samme operation, men med parentes og gemt den resulterende værdi i en ny variabel, det er . Endelig har vi udskrevet denne værdi for brugerne.

Som vi kan observere, at vi får det samme resultat som fra det foregående eksempel, hvilket betyder, at rækkefølgen af ​​beregningen er:

Multiplikation → Etagedeling → Subtraktion

Her er den trinvise beregning af ovenstående:

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

Vi har forstået etageopdelingen rigtigt og dens anvendelse i programmeringssproget Python.

Til sidst vil vi se på en avanceret use case til etageinddelingen. I det følgende tilfælde betyder avanceret ikke hårdt; det er dog ret usædvanligt.

Forståelse af den avancerede brug af Floor Division

Nogle af os er måske klar over, at vi også kan lave brugerdefinerede objekter, der understøtter etageopdelingsoperationen i Python. Dette kan være muligt gennem en særlig metode kendt som __floordiv__() .

__floordiv__() metoden i Python

Etagedelingsoperationen i Python bruges til at dividere to tal og runder resultatet ned til nærmeste heltal.

Det virker under motorhjelmen, fordi en numerisk type implementerer en speciel metode kaldet __floordiv__() . Så, når vi ringer til // operatør mellem to objekter, den __floordiv__() metode bliver kaldt.

I Python kan vi også ringe direkte til __floordiv__() metode. Lad os overveje følgende eksempel, der viser det samme:

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

Produktion:

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

Forklaring:

avl trærotation

I ovenstående kodestykke har vi erklæret to variable som a = 31 og b = 7 . Derefter udførte vi etagedeling vha // operatør og __floordiv__() metode og gemte deres resulterende værdier i to variable, c og d . Endelig har vi udskrevet resultaterne til brugerne.

Fra output vist ovenfor kan vi observere, at begge udtryk har givet det samme resultat. Dette skyldes, at det første udtryk bliver konverteret til det andet udtryk. Med andre ord, disse opkald svarer til hinanden.

Nu bliver tingene interessante. Lad os overveje følgende eksempel.

Eksempel 11.1:

Vi vil oprette en brugerdefineret klasse, der repræsenterer heltalsværdierne som strenge i følgende eksempel. Vi vil derefter oprette to objekter af denne brugerdefinerede klasse og udføre etageopdeling på dem.

Kode:

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

Produktion:

 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' 

Forklaring:

I ovenstående kodestykke har vi defineret en klasse som IntStr der repræsenterer heltalsværdierne som strenge. Vi har så lavet to objekter af IntStr klasse. Endelig har vi etageopdeling indOne genstand af intTo objekt og prøvede at udskrive resultatet.

Ovenstående output indikerer dog en Typefejl . Denne fejlmeddelelse afslører det IntStr genstande understøtter ikke etagedeling. Denne fejl giver mening. Hvordan ville den brugerdefinerede type have nogen anelse om gulvopdelte strengeobjekter?

Men som det viser sig, kan vi lave IntStr objektstøtte etageopdeling.

Tidligere lærte vi, når vi ringer til // operatør, kalder vi __floordiv__() metode. Denne metode udføres et sted i objektets klasse. For eksempel understøtter int-objekter etageopdeling, fordi int-klassen har anvendt __floordiv__() metode.

Disse specielle metoder, som f.eks __floordiv__() , har noget fantastisk til fælles, at vi kan implementere disse metoder i den tilpassede klasse. Med andre ord kan vi få de brugerdefinerede objekter til at understøtte floor division i Python-programmeringssproget.

Lad os nu overveje følgende eksempel, der viser det samme.

Eksempel 11.2:

I det følgende eksempel vil vi implementere __floordiv__() metode ind i IntStr klasse. Vi vil derefter oprette to objekter af denne brugerdefinerede klasse og udføre etageopdeling på dem.

Kode:

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

Produktion:

 17 // 4 = 4 

Forklaring:

I ovenstående kodestykke har vi defineret en klasse som IntStr der repræsenterer heltalsværdierne som strenge. Vi har også implementeret __floordiv__() metode inden for denne klasse. Denne metode accepterer den numeriske strengværdi fra sig selv og et andet objekt. Vi konverterede disse strengværdier til heltal og udførte en etagedeling mellem dem. Vi har derefter konverteret resultatet tilbage til en streng og lavet en ny IntStr objekt. Vi instansierede IntStr klasse med to genstande og udførte en etagedelingsoperation mellem dem. Endelig har vi udskrevet den resulterende værdi for brugerne.

Nu hvor vi med succes forstår metoden til at lave en tilpasset klasse til at understøtte gulvopdeling.

Hvis vi ikke kan lide, at vi skal ringe objekt.val for at se resultatet, kan vi implementere __str__() metode, der direkte returnerer værdien under udskrivning.

Lad os overveje følgende eksempel, der viser det samme.

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

Produktion:

 17 // 4 = 4 

Forklaring:

I ovenstående kodestykke har vi defineret en klasse som IntStr der repræsenterer heltalsværdierne som strenge. Vi har også implementeret __floordiv__() metode inden for denne klasse. Vi har så defineret __str__() metode, der direkte returnerer strengværdierne under udskrivning. Vi instansierede IntStr klasse med to genstande og udførte en etagedelingsoperation mellem dem. Endelig har vi udskrevet den resulterende værdi for brugerne.