TechCodeview

I följande handledning kommer vi att lära oss om Floor Division-operationen med programmeringsspråket Python.

Men innan vi börjar, låt oss kort förstå vad Floor division är.

Förstå golvindelningen

Golvdelning är en normal divisionsoperation, förutom att den returnerar största möjliga heltal. Detta heltal kan antingen vara mindre än den normala divisionsutgången eller lika med den.

Golvfunktionen betecknas med symbolen ⌊ ⌋ i matematiska termer.

Låt oss nu förstå hur Floor divisionen fungerar. Till exempel,

⌊36/5⌋

Steg 1: Utför divisionen först. Vi kommer att dela 36 förbi 5 .

36 ÷ 5 = 7,2

Steg 2: Nu kommer vi att utföra golvfunktionen på värdet vi får efter division, dvs. 7.2 .

⌊7,2⌋=7

Som ett resultat får vi 7 vilket är golvvärdet på 7.2 . Därför betyder våningsindelning dividering och avrundning nedåt till närmaste heltal.

Olika programmeringsspråk erbjuder en speciell inbyggd funktion eller operatör för att beräkna våningsindelning. Några exempel kan vara:

1. Vi kan använda golv() metod i programmeringsspråket C++.
2. Vi kan använda golv() metod i programmeringsspråket Java.
3. Vi kan använda // operatör i programmeringsspråket Python.

Men vi kommer bara att diskutera användningen av våningsindelningsoperationen i Python med hjälp av dubbel-omvänt snedstreck (//) operator .

Förstå Floor Division med Python

I programmeringsspråket Python används våningsdelning för att dela två tal och avrundar resultatet nedåt till närmaste heltal.

Innan vi dyker djupare in i begreppet våningsindelning, låt oss kort påminna oss om innebörden av delning och hur math.floor() funktion i Python.

Utför Regular Division i Python

Vi kan dela två tal genom att använda snedstreck ( / ) divisionsoperatör i Python. Låt oss överväga följande exempel som visar detsamma:

Exempel 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 

Förklaring:

I ovanstående kodavsnitt har vi definierat två variabler som a = 13 och b = 4 . Vi har sedan utfört en divisionsoperation med bakåtstrecket ( / ) divisionsoperatör och lagrade det resulterande värdet i en ny variabel, c . Äntligen har vi skrivit ut värdet på c .

Som vi kan se fungerar division i Python på samma sätt som division fungerar i matematik.

Förstå funktionen math.floor() i Python

Det finns en inbyggd matematikmodul i Python som består av olika användbara matematiska verktyg för beräkningar.

En sådan inbyggd funktion av matematik modulen är math.floor() fungera. Denna funktion accepterar en numerisk inmatning och returnerar golvvärdet genom att avrunda det nedåt till närmaste heltal.

Låt oss överväga följande exempel som visar detsamma:

Exempel 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 

Förklaring:

I kodavsnittet ovan har vi importerat golv() funktion från matematik modul. Vi har då deklarerat två variabler som a = 5,34 och b = -5,34 . Vi har då använt golv() funktion för att beräkna golvvärdena för båda variablerna och lagra dem i nya variabler, c och d . Äntligen har vi skrivit ut resultaten för användarna.

Nu när vi har förstått begreppen delning och golvnummer i Python. Låt oss gå in på detaljerna förknippade med våningsindelningen i Python.

Utför Floor Division i Python

Floor division är en operation i Python som låter oss dela två tal och avrundar det resulterande värdet ner till närmaste heltal. Golvdelningen sker genom dubbel-omvänt snedstreck (//) operator . Syntaxen för densamma visas nedan:

Syntax:

 res = var_1 // var_2 

Var:

resär det resulterande värdet av våningsindelningenvar_1är utdelningenvar_2är divisor

Vi kan tänka oss våningsindelning som den vanliga indelningen i kombination med math.floor() funktionsanrop.

Notera: Golvindelningen kan avrunda vilket tal som helst nedåt till närmaste heltal. Till exempel kommer 3,99 fortfarande att avrundas nedåt till 3.

Låt oss nu överväga ett exempel som visar hur golvindelning fungerar.

Exempel 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 

Förklaring:

I ovanstående kodavsnitt har vi deklarerat två variabler som a = 13 och b = 5 . Vi har då använt // operatör för att beräkna våningsdelningsvärdet och lagrade golvvärdet i en ny variabel, c . Vi har sedan utfört den vanliga uppdelningen med hjälp av / operator och lagrade värdet i en annan variabel, d . Äntligen har vi skrivit ut båda resultaten och jämfört dem.

Låt oss nu överväga ett annat exempel med hjälp av math.floor() fungera.

Exempel 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 

Förklaring:

Vi har importerat golv() funktion från matematik modul i kodavsnittet ovan. Vi har då deklarerat två variabler som a = 17 och b = 5 . Vi använde sedan golv() funktion, delad a förbi b och lagrade den i variabel c. Vi har sedan beräknat golvvärdet med hjälp av // operator och lagrade värdet i en ny variabel, d . Äntligen har vi skrivit ut båda värdena och jämfört dem.

Utför Floor Division med negativa tal

Vi kan även utföra våningsindelning med negativa tal.

I fallet med negativa tal avrundas det resulterande värdet fortfarande nedåt till närmaste heltal. Vissa kan bli förvirrade av att avrunda ett negativt tal nedåt innebär att gå bort från noll. Till exempel, -23 är golv ner till -3 .

Låt oss överväga ett exempel som visar våningsindelningen med negativa tal.

Exempel 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 

Förklaring:

I ovanstående kodavsnitt har vi deklarerat två variabler som a = -10 och b = 4 . Vi har då använt // operatör för att beräkna golvvärdet och lagra det i en ny variabel, c . Äntligen har vi skrivit ut värdet för användaren.

Med en vanlig division, -10/4 skulle återvända -2,5 ; men med en våningsindelning avrundas detta tal nedåt till närmaste negativa heltal, dvs -3 .

Utför Floor Division med Floats

Vi kan även utföra Floor division med flöten i Python. När golvdelande flyter är resultatet ett flytande som representerar närmaste heltal.

Låt oss överväga följande exempel som visar golvindelningen med hjälp av flottörer.

Exempel 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 

Förklaring:

I ovanstående kodavsnitt har vi initierat två listor. Vi har då använt för -loop för att iterera genom elementen i dessa listor, beräknade värdena för varje våningsindelningsoperation och skrev ut resultaten för användarna.

Som ett resultat kan vi observera att våningsdelningsoperationen utförs med hjälp av flöten och float med heltal returnerar värdet avrundat nedåt till närmaste heltal representerat som float.

Floor Division och Modulo i Python

Inom matematik är modulo ett begrepp som främst förknippas med våningsindelning. Vi kan också säga att modulo betyder resten i divisionen mellan två tal. Med andra ord kan vi räkna antalet rester med den.

Vi kan beräkna modulo i Python med hjälp av procenten ( % ) operatör.

Låt oss betrakta ett exempel som illustrerar förhållandet mellan våningsindelningen och modulo i Python.

Exempel 7.1:

Givet 13 godisar och 4 ätare kan vi beräkna antalet godisar varje ätare får med hjälp av våningsindelningen.

Koda:

 # 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 

Förklaring:

I ovanstående kodavsnitt har vi deklarerat några variabler som anger antalet godis och ätare. Vi har då använt // operatör att utföra våningsindelning för att beräkna antalet godis varje ätare får. Vi har sedan skrivit ut dessa värden för användaren.

Låt oss nu beräkna det totala antalet godis som delas mellan gruppen. Det här är inte särskilt viktigt.

Exempel 7.2:

Vi kommer att multiplicera antalet godis per person med antalet ätare.

Koda:

 # 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 

Förklaring:

I ovanstående kodavsnitt har vi beräknat det totala antalet godis som delas mellan gruppen genom att multiplicera antalet godisar per person med antalet ätande och skrivit ut det resulterande värdet för användarna.

Det totala antalet fulla godis som delas är 12 . Det totala antalet godis är dock 13 . Detta uttalande antyder att en godis blir över och inte kommer att ätas.

Ovanstående exempel beskriver ett sätt att beräkna antalet rester. Men om vi bara är intresserade av antalet rester kan vi direkt räkna ut det med hjälp av modulo.

Exempel 7.3:

Med tanke på 13 godisar och 4 ätare, vad är antalet överblivna godisar?

Koda:

 # 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 

Förklaring:

I ovanstående kodavsnitt har vi deklarerat variablerna som lagrar värdet godis och ätare. Vi har sedan beräknat antalet överblivna godisar med hjälp av % operatör som betecknar modulo-operationen. Äntligen har vi skrivit ut några uttalanden och resulterande värden för användarna. Som ett resultat kan vi se att det överblivna godiset är 1 .

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

I Python är våningsindelningen och modulo relaterade med följande ekvation:

Var:

aär utdelningen.bär divisor.

Låt oss till exempel verifiera att ovanstående ekvation gäller för de 13 godisarna och de 4 ätarna.

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

Således har vi förstått begreppen våningsindelning och modulo i Python. Nu ska vi titta på någon inbyggd funktion som beräknar båda.

Förstå funktionen divmod() i Python

Python erbjuder en inbyggd funktion som heter divmod() som gör att vi kan beräkna både våningsdelningen och modulo mellan två numeriska värden.

Syntaxen för divmod() funktionen visas nedan:

Syntax:

 res = divmod(var_1, var_2) 

Var:

resär resultatet som en tupel. Denna tuppel har golvdelningsresultatet och resten ges av modulo.var_1är utdelningen.var_2är divisor.

Låt oss nu överväga följande exempel som visar divmod() fungera.

1 miljon i siffror

Exempel 8:

Med tanke på 13 godisar och 4 ätare, hur många fulla godisar får varje ätare och hur många godis kvar?

Koda:

 # 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 

Förklaring:

I ovanstående kodavsnitt har vi deklarerat några variabler. Vi har använt divmod() funktion för att beräkna våningsdelningsvärdet och modulo för de givna variablerna. Vi har sedan skrivit ut dessa värden för användarna.

Förstå Floor Division Precedence

I Python, våningsindelningsoperatören // har samma prioritetsnivå som multiplikation ( * ), division ( / ), och modulo ( % ).

Detta påstående innebär att om vi multiplicerar och sedan golvdelar, uppnås multiplikationen först, och sedan våningsdelningen och vice versa.

Men om vi till exempel subtraherar två tal och sedan utför våningsindelning, kommer våningsindelningsoperationen att bana väg.

Låt oss överväga ett exempel som visar detsamma.

Exempel 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 

Förklaring:

I kodavsnittet ovan har vi deklarerat några variabler som a = 3, b = 5, c = 6 , och d = 7 . Vi har sedan utfört en operation och lagrat det resulterande värdet i en ny variabel, Det är . Äntligen har vi skrivit ut detta värde för användarna.

För att förstå hur detta resultat beräknas kan vi sätta in parentes runt termerna i rätt prioritetsordning.

Exemplet nedan visar samma sak:

Exempel 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 

Förklaring:

I kodavsnittet ovan har vi deklarerat några variabler som a = 3, b = 5, c = 6 , och d = 7 . Vi har sedan utfört samma operation men med parentes och lagrat det resulterande värdet i en ny variabel, Det är . Äntligen har vi skrivit ut detta värde för användarna.

Som vi kan observera att vi får samma resultat som från föregående exempel, vilket betyder att beräkningsordningen är:

Multiplikation → Golvdelning → Subtraktion

Här är den stegvisa beräkningen av ovanstående:

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

Vi har förstått våningsindelningen ordentligt och dess användning i programmeringsspråket Python.

Till sist ska vi titta på ett avancerat användningsfall för våningsindelningen. I följande fall innebär avancerat inte svårt; det är dock ganska ovanligt.

Förstå den avancerade användningen av Floor Division

Vissa av oss kanske är medvetna om att vi också kan göra anpassade objekt som stödjer våningsindelningsoperationen i Python. Detta kan vara möjligt genom en speciell metod som kallas __floordiv__() .

Metoden __floordiv__() i Python

Golvdelningsoperationen i Python används för att dividera två tal och avrundar resultatet nedåt till närmaste heltal.

Det fungerar under huven eftersom en numerisk typ implementerar en speciell metod som kallas __floordiv__() . Sedan, när vi ringer till // operatör mellan två objekt, den __floordiv__() metoden anropas.

I Python kan vi också direkt anropa __floordiv__() metod. Låt oss överväga följande exempel som visar detsamma:

Exempel 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 

Förklaring:

I ovanstående kodavsnitt har vi deklarerat två variabler som a = 31 och b = 7 . Vi utförde sedan golvdelning med hjälp av // operatör och __floordiv__() metod och lagrade deras resulterande värden i två variabler, c och d . Äntligen har vi skrivit ut resultaten för användarna.

Från utgången som visas ovan kan vi observera att båda uttrycken har gett samma resultat. Detta beror på att det första uttrycket konverteras till det andra uttrycket. Med andra ord är dessa samtal likvärdiga med varandra.

Nu blir det intressant. Låt oss överväga följande exempel.

Exempel 11.1:

Vi kommer att skapa en anpassad klass som representerar heltalsvärdena som strängar i följande exempel. Vi kommer sedan att skapa två objekt av denna anpassade klass och utföra våningsindelning på dem.

Koda:

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

Förklaring:

I ovanstående kodavsnitt har vi definierat en klass som IntStr som representerar heltalsvärdena som strängar. Vi har sedan skapat två objekt av IntStr klass. Äntligen har vi golvdelning intonera objekt av intTwo objekt och försökte skriva ut resultatet.

Ovanstående utdata indikerar dock en Skrivfel . Detta felmeddelande avslöjar det IntStr föremål stöder inte våningsindelning. Detta fel är vettigt. Hur skulle den anpassade typen ha någon aning om golvdelande strängobjekt?

Men som det visar sig kan vi göra IntStr objektstöd golvindelning.

Tidigare har vi lärt oss när vi ringer // operatör, vi kallar __floordiv__() metod. Denna metod exekveras någonstans i objektets klass. Till exempel stöder int-objekt våningsindelning eftersom int-klassen har tillämpat __floordiv__() metod.

Dessa speciella metoder, som __floordiv__() , har något fantastiskt gemensamt att vi kan implementera dessa metoder i den anpassade klassen. Med andra ord kan vi få de anpassade objekten att stödja våningsindelning i programmeringsspråket Python.

Låt oss nu betrakta följande exempel som visar detsamma.

Exempel 11.2:

I följande exempel kommer vi att implementera __floordiv__() metod in i IntStr klass. Vi kommer sedan att skapa två objekt av denna anpassade klass och utföra våningsindelning på dem.

Koda:

 # 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 

Förklaring:

I ovanstående kodavsnitt har vi definierat en klass som IntStr som representerar heltalsvärdena som strängar. Vi har också implementerat __floordiv__() metod inom denna klass. Denna metod accepterar det numeriska strängvärdet från sig själv och ett annat objekt. Vi konverterade dessa strängvärden till heltal och utförde en våningsindelning mellan dem. Vi har sedan omvandlat resultatet tillbaka till en sträng och skapat en ny IntStr objekt. Vi instansierade IntStr klass med två objekt och utförde en våningsdelningsoperation mellan dem. Äntligen har vi skrivit ut det resulterande värdet för användarna.

Nu när vi framgångsrikt förstår metoden för att göra en anpassad klass för att stödja våningsindelning.

Om vi ​​inte gillar det faktum att vi måste ringa objekt.val för att se resultatet kan vi implementera __str__() metod som direkt returnerar värdet under utskrift.

Låt oss överväga följande exempel som visar detsamma.

Exempel 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 

Förklaring:

I ovanstående kodavsnitt har vi definierat en klass som IntStr som representerar heltalsvärdena som strängar. Vi har också implementerat __floordiv__() metod inom denna klass. Vi har då definierat __str__() metod som direkt returnerar strängvärdena under utskrift. Vi instansierade IntStr klass med två objekt och utförde en våningsdelningsoperation mellan dem. Äntligen har vi skrivit ut det resulterande värdet för användarna.