I den følgende opplæringen vil vi lære om Floor Division-operasjonen ved å bruke Python-programmeringsspråket.
Men før vi kommer i gang, la oss kort forstå hva Floor Division er.
Forstå etasjeinndelingen
Etasjedeling er en normal delingsoperasjon, bortsett fra at den returnerer størst mulig heltall. Dette hele tallet kan enten være mindre enn den normale divisjonsutgangen eller lik den.
Gulvfunksjonen er betegnet med ⌊ ⌋-symbolet i matematiske termer.
La oss nå forstå hvordan gulvdivisjonen fungerer. For eksempel,
⌊36/5⌋
Trinn 1: Utføre divisjonen først. Vi vil dele 36 av 5 .
36 ÷ 5 = 7,2
Steg 2: Nå vil vi utføre gulvfunksjonen på verdien vi får etter deling, dvs. 7.2 .
⌊7,2⌋=7
Som et resultat får vi 7 som er gulvverdien av 7.2 . Derfor betyr etasjedeling å dele og avrunde ned til nærmeste heltall.
Ulike programmeringsspråk tilbyr en spesiell innebygd funksjon eller operatør for å beregne etasjeinndeling. Noen eksempler kan være:
- Vi kan bruke gulv() metode i programmeringsspråket C++.
- Vi kan bruke gulv() metode i programmeringsspråket Java.
- Vi kan bruke // operatør i programmeringsspråket Python.
Imidlertid vil vi bare diskutere bruken av etasjedelingsoperasjonen i Python ved hjelp av operatør med dobbel omvendt skråstrek (//). .
Forstå gulvinndeling ved hjelp av Python
I programmeringsspråket Python brukes etasjedeling for å dele to tall og avrunder utfallet ned til nærmeste heltall.
Før vi dykker dypere inn i begrepet etasjedeling, la oss kort minne oss selv på betydningen av deling og virkemåten til math.floor() funksjon i Python.
Utfører Regular Division i Python
Vi kan dele to tall ved å bruke skråstreken ( / ) divisjonsoperatør i Python. La oss vurdere følgende eksempel som viser det samme:
Eksempel 1:
# declaring variables a = 13 b = 4 # performing regular division c = a / b # printing the result print(a, '/', b, '=', c)
Produksjon:
13 / 4 = 3.25
Forklaring:
I kodebiten ovenfor har vi definert to variabler som a = 13 og b = 4 . Vi har deretter utført en delingsoperasjon ved å bruke skråstreken ( / ) divisjonsoperatør og lagret den resulterende verdien i en ny variabel, c . Endelig har vi skrevet ut verdien av c .
Som vi kan se, fungerer divisjon i Python på samme måte som divisjon fungerer i matematikk.
Forstå funksjonen math.floor() i Python
Det er en innebygd matematikkmodul i Python som består av forskjellige nyttige matematiske verktøy for beregninger.
En slik innebygd funksjon av matte modulen er math.floor() funksjon. Denne funksjonen aksepterer en numerisk inngang og returnerer gulvverdien ved å runde den ned til nærmeste heltall.
La oss vurdere følgende eksempel som 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)
Produksjon:
Floor value of 5.34 = 5 Floor value of -5.34 = 6
Forklaring:
I kodebiten ovenfor har vi importert gulv() funksjon fra matte modul. Vi har da erklært to variabler som a = 5,34 og b = -5,34 . Vi har da brukt gulv() funksjon for å beregne gulvverdiene til begge variablene og lagre dem i nye variabler, c og d . Endelig har vi skrevet ut resultatene for brukerne.
Nå som vi har forstått konseptene med deling og gulvtall i Python. La oss gå inn på detaljene knyttet til etasjeinndelingen i Python.
Utfører Floor Division i Python
Etasjedeling er en operasjon i Python som lar oss dele to tall og runder den resulterende verdien ned til nærmeste heltall. Gulvdelingen skjer gjennom operatør med dobbel omvendt skråstrek (//). . Syntaksen for det samme er vist nedenfor:
støpt inn til streng
Syntaks:
res = var_1 // var_2
Hvor:
Vi kan tenke på etasjeinndeling som den vanlige inndelingen kombinert med math.floor() funksjonsanrop.
Merk: Etasjeinndelingen kan runde et hvilket som helst tall ned til nærmeste heltall. For eksempel vil 3,99 fortsatt bli rundet ned til 3.
La oss nå se på et eksempel som viser hvordan gulvdeling fungerer.
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)
Produksjon:
Floor Division: 13 // 5 = 2 Regular Division: 13 / 5 = 2.6
Forklaring:
I kodebiten ovenfor har vi deklarert to variabler som a = 13 og b = 5 . Vi har da brukt // operatør for å beregne etasjedelingsverdien og lagret etasjeverdien i en ny variabel, c . Vi har da utført den vanlige inndelingen ved hjelp av / operatør og lagret verdien i en annen variabel, d . Endelig har vi skrevet ut begge resultatene og sammenlignet dem.
La oss nå vurdere et annet eksempel ved å bruke math.floor() funksjon.
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)
Produksjon:
Floor Division using floor() function: 3 Floor Division using // operator: 3
Forklaring:
Vi har importert gulv() funksjon fra matte modul i kodebiten ovenfor. Vi har da erklært to variabler som a = 17 og b = 5 . Vi brukte da gulv() funksjon, delt en av b , og lagret den i variabel c. Vi har da beregnet gulvverdien ved hjelp av // operatør og lagret verdien i en ny variabel, d . Endelig har vi skrevet ut begge verdiene og sammenlignet dem.
Utføre etasjeinndeling med negative tall
Vi kan også utføre etasjedeling ved hjelp av negative tall.
Ved negative tall rundes den resulterende verdien fortsatt ned til nærmeste heltall. Noen kan bli forvirret ved å runde ned et negativt tall betyr å gå bort fra null. For eksempel, -23 er gulvet ned til -3 .
La oss vurdere et eksempel som viser etasjeinndelingen med negative tall.
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)
Produksjon:
Floor Division: -10 // 4 = -3
Forklaring:
I kodebiten ovenfor har vi deklarert to variabler som a = -10 og b = 4 . Vi har da brukt // operatør for å beregne gulvverdien og lagret den i en ny variabel, c . Endelig har vi skrevet ut verdien for brukeren.
Med en vanlig divisjon, -10/4 ville komme tilbake -2,5 ; men med en etasjeinndeling rundes dette tallet ned til nærmeste negative heltall, dvs. til -3 .
Utføre gulvinndeling med flytere
Vi kan også utføre Gulvdeling med flottører i Python. Når etasjedeler flyter, er utfallet en flottør som representerer nærmeste heltall.
pandas standardavvik
La oss vurdere følgende eksempel som demonstrerer gulvinndelingen ved bruk av flottører.
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)
Produksjon:
17.5 // 3.3 = 5.0 10 // 2.5 = 4.0 13.4 // 3 = 4.0
Forklaring:
I kodebiten ovenfor har vi initialisert to lister. Vi har da brukt til -løkke for å iterere gjennom elementene i disse listene, beregnet verdiene for hver etasjeinndelingsoperasjon, og skrive ut resultatene for brukerne.
Som et resultat kan vi observere at etasjedelingsoperasjonen utføres ved bruk av flyter og flyt med heltall returnerer verdien avrundet ned til nærmeste heltall representert som flyter.
Floor Division og Modulo i Python
I matematikk er modulo et konsept hovedsakelig knyttet til etasjeskille. Vi kan også si at modulo betyr resten i divisjonen mellom to tall. Med andre ord kan vi telle antall rester med den.
Vi kan beregne modulo i Python ved å bruke prosenten ( % ) operatør.
La oss se på et eksempel som illustrerer forholdet mellom etasjeinndeling og modulo i Python.
Eksempel 7.1:
Gitt 13 godterier og 4 spisere, kan vi beregne antall godterier hver spiser får ved hjelp av etasjeinndelingen.
Kode:
støpt 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)
Produksjon:
Number of Candies: 13 Number of Eaters: 4 The number of candies each eater gets: 3
Forklaring:
I kodebiten ovenfor har vi deklarert noen variabler som indikerer antall godteri og spisere. Vi har da brukt // operatør for å utføre etasjedeling for å beregne antall godteri hver spiser får. Vi har så skrevet ut disse verdiene for brukeren.
La oss nå beregne det totale antallet godterier som deles mellom gruppen. Dette er ikke veldig viktig.
Eksempel 7.2:
Vi vil gange antall godteri per person med antall 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)
Produksjon:
The total number of candies being shared among the group: 12
Forklaring:
I kodebiten ovenfor har vi beregnet det totale antallet godteri som deles mellom gruppen ved å multiplisere antall godteri per person med antall spisere og skrevet ut den resulterende verdien for brukerne.
Det totale antallet fulle godteri delt er 12 . Imidlertid er det totale antallet godteri 1. 3 . Denne uttalelsen antyder at ett godteri vil være til overs og ikke kommer til å bli spist.
Eksempelet ovenfor beskriver en måte å beregne antall rester på. Men hvis vi kun er interessert i antall rester, kan vi direkte beregne det ved hjelp av modulo.
Eksempel 7.3:
Gitt 13 godterier og 4 spisere, hva er antall rester av godteri?
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)
Produksjon:
Number of Candies: 13 Number of Eaters: 4 Total number of Leftover Candies: 1
Forklaring:
I kodebiten ovenfor har vi deklarert variablene som lagrer verdien godteri og spisere. Vi har så regnet ut antall rester av godteri ved hjelp av % operatør som angir modulo-operasjonen. Endelig har vi skrevet ut noen utsagn og resulterende verdier for brukerne. Som et resultat kan vi se at rester av godteri er 1 .
a = b * (a // b) + (a % b)
I Python er etasjeinndelingen og moduloen relatert med følgende ligning:
Hvor:
La oss for eksempel verifisere at ligningen ovenfor gjelder for de 13 godteri og 4 spisere.
13 = 4 * (13 // 4) + (13 % 4)
13 = 4 * 3 + 1
13 = 13
Dermed har vi forstått begrepene etasjeinndeling og modulo i Python. Nå skal vi se på en innebygd funksjon som beregner begge deler.
Forstå divmod()-funksjonen i Python
Python tilbyr en innebygd funksjon kalt divmod() som lar oss beregne både etasjeskillet og modulo mellom to numeriske verdier.
Syntaksen for divmod() funksjonen er vist nedenfor:
Syntaks:
res = divmod(var_1, var_2)
Hvor:
La oss nå vurdere følgende eksempel som viser divmod() funksjon.
Eksempel 8:
Gitt 13 godteri og 4 spisere, hvor mange fulle godteri får hver spiser, og hvor mange godteri er det igjen?
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)
Produksjon:
Number of Candies: 13 Number of Eaters: 4 Number of Candies per eater: 3 Total number of Leftover Candies: 1
Forklaring:
I kodebiten ovenfor har vi deklarert noen variabler. Vi har brukt divmod() funksjon for å beregne etasjedelingsverdien og moduloen for de gitte variablene. Vi har så skrevet ut disse verdiene for brukerne.
Forstå gulvinndelingens forrang
I Python, gulvdelingsoperatøren // har samme prioritetsnivå som multiplikasjon ( * ), divisjon ( / ), og modulo ( % ).
Dette utsagnet innebærer at hvis vi multipliserer, og deretter etasjedeler, oppnås multiplikasjonen først, og deretter etasjedivisjonen og omvendt.
Men hvis vi for eksempel trekker fra to tall og deretter utfører etasjedeling, vil etasjedelingsoperasjonen bane vei.
La oss se på et eksempel som 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)
Produksjon:
3 * 5 // 6 - 7 = -5
Forklaring:
I kodebiten ovenfor har vi erklært noen variabler som a = 3, b = 5, c = 6 , og d = 7 . Vi har deretter utført en operasjon og lagret den resulterende verdien i en ny variabel, Det er . Endelig har vi skrevet ut denne verdien for brukerne.
For å forstå hvordan dette resultatet beregnes, kan vi sette inn parentes rundt begrepene i riktig prioritetsrekkefølge.
Eksemplet nedenfor viser det samme:
kaller js-funksjonen 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)
Produksjon:
(( 3 * 5 ) // 6 ) - 7 = -5
Forklaring:
I kodebiten ovenfor har vi erklært noen variabler som a = 3, b = 5, c = 6 , og d = 7 . Vi har da utført den samme operasjonen men med parentes og lagret den resulterende verdien i en ny variabel, Det er . Endelig har vi skrevet ut denne verdien for brukerne.
Som vi kan observere at vi får det samme resultatet som fra forrige eksempel, noe som betyr at beregningsrekkefølgen er:
Multiplikasjon → Etasjedeling → Subtraksjon
Her er den trinnvise beregningen av ovenstående:
3 * 5 // 6 - 7
((3 * 5) // 6) - 7
(15 // 6) - 7
2 - 7
-5
Vi har forstått etasjeinndelingen ordentlig og bruken av den i programmeringsspråket Python.
Til slutt skal vi se på en avansert brukssak for etasjeskillet. I følgende tilfelle betyr avansert ikke vanskelig; det er imidlertid ganske uvanlig.
Forstå den avanserte bruken av gulvinndeling
Noen av oss er kanskje klar over at vi også kan lage tilpassede objekter som støtter etasjedelingsoperasjonen i Python. Dette kan være mulig gjennom en spesiell metode kjent som __floordiv__() .
__floordiv__()-metoden i Python
Etasjedelingsoperasjonen i Python brukes til å dele to tall og runder resultatet ned til nærmeste heltall.
Det fungerer under panseret fordi en numerisk type implementerer en spesiell metode kalt __floordiv__() . Deretter, når vi ringer // operatør mellom to objekter, den __floordiv__() metoden kalles.
I Python kan vi også ringe direkte til __floordiv__() metode. La oss vurdere følgende eksempel som 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)
Produksjon:
Using the // operator: 31 // 7 = 4 Using the __floordiv__() method: ( 31 ).__floordiv__( 7 ) = 4
Forklaring:
avl trerotasjon
I kodebiten ovenfor har vi deklarert to variabler som a = 31 og b = 7 . Vi utførte deretter etasjedeling ved hjelp av // operatør og __floordiv__() metode og lagret deres resulterende verdier i to variabler, c og d . Endelig har vi skrevet ut resultatene for brukerne.
Fra utgangen vist ovenfor kan vi observere at begge uttrykkene har gitt samme resultat. Dette er fordi det første uttrykket blir konvertert til det andre uttrykket. Med andre ord, disse samtalene er likeverdige med hverandre.
Nå blir ting interessant. La oss vurdere følgende eksempel.
Eksempel 11.1:
Vi vil lage en egendefinert klasse som representerer heltallsverdiene som strenger i følgende eksempel. Vi vil deretter lage to objekter av denne tilpassede klassen og utføre etasjedelingsoperasjoner 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)
Produksjon:
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 kodebiten ovenfor har vi definert en klasse som IntStr som representerer heltallsverdiene som strenger. Vi har da laget to objekter av IntStr klasse. Endelig har vi gulvdeling innOne gjenstand av intTo objekt og prøvde å skrive ut resultatet.
Imidlertid indikerer utgangen ovenfor en TypeError . Denne feilmeldingen avslører det IntStr objekter støtter ikke etasjedeling. Denne feilen gir mening. Hvordan ville den tilpassede typen ha noen anelse om gjenstander for gulvdelingsstrenger?
Imidlertid, som det viser seg, kan vi gjøre IntStr objektstøtte etasjeinndeling.
Tidligere har vi lært når vi ringer // operatør, kaller vi __floordiv__() metode. Denne metoden utføres et sted i klassen til objektet. For eksempel støtter int-objekter etasjedeling fordi int-klassen har brukt __floordiv__() metode.
Disse spesielle metodene, som __floordiv__() , har noe utrolig til felles at vi kan implementere disse metodene i den tilpassede klassen. Med andre ord kan vi få de tilpassede objektene til å støtte etasjeinndeling i programmeringsspråket Python.
La oss nå se på følgende eksempel som viser det samme.
Eksempel 11.2:
I følgende eksempel vil vi implementere __floordiv__() metoden inn i IntStr klasse. Vi vil deretter lage to objekter av denne tilpassede klassen og utføre etasjedelingsoperasjoner 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)
Produksjon:
17 // 4 = 4
Forklaring:
I kodebiten ovenfor har vi definert en klasse som IntStr som representerer heltallsverdiene som strenger. Vi har også implementert __floordiv__() metode innenfor denne klassen. Denne metoden aksepterer den numeriske strengverdien fra seg selv og et annet objekt. Vi konverterte disse strengverdiene til heltall og utførte en etasjedeling mellom dem. Vi har deretter konvertert resultatet tilbake til en streng og laget en ny IntStr gjenstand. Vi instansierte IntStr klasse med to objekter og utførte en etasjeskilleoperasjon mellom dem. Endelig har vi skrevet ut den resulterende verdien for brukerne.
Nå som vi har lykkes med å forstå metoden for å lage en tilpasset klasse for å støtte gulvdeling.
Hvis vi ikke liker det faktum at vi må ringe objekt.val for å se resultatet, kan vi implementere __str__() metode som returnerer verdien direkte under utskrift.
La oss se på følgende eksempel som 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)
Produksjon:
17 // 4 = 4
Forklaring:
I kodebiten ovenfor har vi definert en klasse som IntStr som representerer heltallsverdiene som strenger. Vi har også implementert __floordiv__() metode innenfor denne klassen. Vi har da definert __str__() metode som returnerer strengverdiene direkte under utskrift. Vi instansierte IntStr klasse med to objekter og utførte en etasjeskilleoperasjon mellom dem. Endelig har vi skrevet ut den resulterende verdien for brukerne.