A következő oktatóanyagban megismerjük a Floor Division működését a Python programozási nyelv használatával.
Mielőtt azonban elkezdenénk, röviden értsük meg, mi az a Floor felosztás.
A Floor felosztás megértése
Az emeletosztás egy normál osztási művelet, kivéve, hogy a lehető legnagyobb egész számot adja vissza. Ez az egész szám lehet kisebb, mint a normál osztás kimenete, vagy egyenlő vele.
ökör vs bika
A padlófüggvényt a ⌊ ⌋ szimbólum jelöli matematikai értelemben.
Most ismerjük meg a Floor divízió működését. Például,
⌊36/5⌋
1. lépés: Először az osztás végrehajtása. osztani fogunk 36 által 5 .
36 ÷ 5 = 7,2
2. lépés: Most a padlófüggvényt az osztás után kapott értéken hajtjuk végre, azaz 7.2 .
⌊7,2⌋=7
Ennek eredményeként azt kapjuk 7 ami minimumértéke 7.2 . Ezért a padlóosztás osztást és lefelé kerekítést jelent a legközelebbi egész számra.
A különböző programozási nyelvek egy adott beépített funkciót vagy operátort kínálnak a padlóosztás kiszámításához. Néhány példa lehet:
- Használhatjuk a padló() módszer a C++ programozási nyelvben.
- Használhatjuk a padló() módszer a Java programozási nyelvben.
- Használhatjuk a // operátor a Python programozási nyelven.
Mindazonáltal csak a padlóosztás műveletének Pythonban való használatát tárgyaljuk a segítségével kettős fordított perjel (//) operátor .
A Floor Division megértése Python használatával
A Python programozási nyelvben a padlóosztás két szám elosztására szolgál, és az eredményt a legközelebbi egész számra kerekíti.
Mielőtt mélyebben belemerülnénk a padlófelosztás fogalmába, röviden emlékeztessük magunkat az osztás jelentésére és a padlófelosztás működésére. math.floor() függvény Pythonban.
Rendszeres felosztás végrehajtása Pythonban
Két számot a fordított perjel ( / ) részleg operátor Pythonban. Tekintsük a következő példát, amely ugyanezt mutatja be:
1. példa:
# declaring variables a = 13 b = 4 # performing regular division c = a / b # printing the result print(a, '/', b, '=', c)
Kimenet:
13 / 4 = 3.25
Magyarázat:
A fenti kódrészletben két változót definiáltunk, mint a = 13 és b = 4 . Ezután végrehajtottunk egy osztási műveletet a fordított perjel ( / ) osztás operátor, és az eredményül kapott értéket egy új változóban tárolta, c . Végre kinyomtattuk az értékét c .
Amint látjuk, a Pythonban az osztás ugyanúgy működik, mint a matematikában.
A math.floor() függvény megértése Pythonban
A Pythonban van egy beépített matematikai modul, amely különféle hasznos matematikai segédprogramokból áll a számításokhoz.
Az egyik ilyen beépített funkció a matematika modul az math.floor() funkció. Ez a függvény elfogadja a numerikus bevitelt, és a legalacsonyabb értéket a legközelebbi egész számra kerekítve adja vissza.
Tekintsük a következő példát, amely ugyanezt mutatja be:
2. példa:
# 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)
Kimenet:
Floor value of 5.34 = 5 Floor value of -5.34 = 6
Magyarázat:
A fenti kódrészletben importáltuk a padló() függvény a matematika modult. Ezután két változót deklaráltunk mint a = 5,34 és b = -5,34 . Ezután használtuk a padló() függvény mindkét változó alsó értékének kiszámításához és új változókban való tárolásához, c és d . Végre kinyomtattuk az eredményeket a felhasználók számára.
Most, hogy megértettük az osztó- és padlószámok fogalmát a Pythonban. Térjünk át a Python padlófelosztásához kapcsolódó részletekre.
Floor Division végrehajtása Pythonban
A szintosztás egy olyan művelet a Pythonban, amely lehetővé teszi két szám elosztását, és az eredményül kapott értéket a legközelebbi egész számra kerekíti. A padlófelosztás a kettős fordított perjel (//) operátor . A szintaxis az alábbiakban látható:
Szintaxis:
res = var_1 // var_2
Ahol:
Felosztásra gondolhatunk úgy, mint a szabályos felosztásra kombinálva a math.floor() függvényhívás.
Megjegyzés: A padlóosztás bármely számot lefelé kerekíthet a legközelebbi egész számra. Például a 3,99 továbbra is le lesz kerekítve 3-ra.
Nézzünk most egy példát, amely bemutatja a padlófelosztás működését.
3. példa:
# 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)
Kimenet:
Floor Division: 13 // 5 = 2 Regular Division: 13 / 5 = 2.6
Magyarázat:
A fenti kódrészletben két változót deklaráltunk mint a = 13 és b = 5 . Ezután használtuk a // a kezelő kiszámítja a padlóosztás értékét, és eltárolja a minimális értéket egy új változóban, c . Ezután elvégeztük a szabályos felosztást a / operátort, és eltárolta az értéket egy másik változóban, d . Végül mindkét eredményt kinyomtattuk és összehasonlítottuk.
Most nézzünk meg egy másik példát a math.floor() funkció.
4. példa:
# 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)
Kimenet:
Floor Division using floor() function: 3 Floor Division using // operator: 3
Magyarázat:
Importáltuk a padló() funkció a matematika modult a fenti kódrészletben. Ezután két változót deklaráltunk mint a = 17 és b = 5 . Ezután használtuk a padló() funkció, osztva a által b , és eltárolta a c változóban. Ezután kiszámítottuk a minimális értéket a segítségével // operátort, és eltárolta az értéket egy új változóban, d . Végül mindkét értéket kinyomtattuk és összehasonlítottuk.
Emeletosztás végrehajtása negatív számokkal
Negatív számok felhasználásával padlóosztást is végezhetünk.
Negatív számok esetén a kapott értéket továbbra is lefelé kerekítjük a legközelebbi egész számra. Egyeseket összezavarhat, ha egy negatív szám lefelé kerekítése azt jelenti, hogy nullától eltérnek. Például, -23 le van padlózva -3 .
Tekintsünk egy példát, amely negatív számokkal szemlélteti a padlóosztást.
5. példa:
# declaring the variables a = -10 b = 4 # calculating floor value using // operator c = a // b # printing the value print('Floor Division:', a, '//', b, '=', c)
Kimenet:
Floor Division: -10 // 4 = -3
Magyarázat:
A fenti kódrészletben két változót deklaráltunk mint a = -10 és b = 4 . Ezután használtuk a // operátort a minimális érték kiszámításához és egy új változóban tárolásához, c . Végre kinyomtattuk az értéket a felhasználó számára.
Rendszeres felosztással, -10/4 visszatérne -2.5 ; azonban padlóosztásnál ezt a számot lefelé kerekítik a legközelebbi negatív egész számra, azaz -3 .
Floor Division végrehajtása úszókkal
Pythonban Floor-osztást is végrehajthatunk floatokkal. A padlóosztó lebegéseknél az eredmény egy lebegőpont, amely a legközelebbi egész számot reprezentálja.
Tekintsük a következő példát, amely bemutatja a padlófelosztást úszók segítségével.
6. példa:
# 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)
Kimenet:
17.5 // 3.3 = 5.0 10 // 2.5 = 4.0 13.4 // 3 = 4.0
Magyarázat:
A fenti kódrészletben két listát inicializáltunk. Ezután használtuk a számára -loop a listák elemeinek iterálásához, kiszámította az egyes emeletfelosztási műveletek értékeit, és kinyomtatta az eredményeket a felhasználók számára.
Ennek eredményeként megfigyelhető, hogy a padlóosztás műveletet lebegésekkel hajtják végre, és a float with integer visszaadja az értéket lefelé kerekítve a legközelebbi egész számra, amelyet lebegtetésként ábrázolnak.
Floor Division és Modulo a Pythonban
A matematikában a modulo egy olyan fogalom, amely elsősorban a padlófelosztáshoz kapcsolódik. Úgy is fogalmazhatunk, hogy a modulo a két szám közötti osztás maradékát jelenti. Vagyis meg tudjuk számolni vele a maradékok számát.
Kiszámolhatjuk a modulo-t Pythonban a százalékos ( % ) operátor.
Tekintsünk egy példát, amely a Pythonban a padlófelosztás és a modulo közötti kapcsolatot illusztrálja.
7.1. példa:
Adott 13 cukorka és 4 evő, a padlófelosztás segítségével kiszámíthatjuk, hogy egy-egy evő mennyi cukorkát kap.
Kód:
# 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)
Kimenet:
Number of Candies: 13 Number of Eaters: 4 The number of candies each eater gets: 3
Magyarázat:
A fenti kódrészletben deklaráltunk néhány változót, amelyek a cukorkák és az evők számát jelzik. Ezután használtuk a // kezelőnek, hogy végre hajtsa a padlófelosztást, hogy kiszámítsa az egyes evőkhöz jutó cukorkák számát. Ezután kinyomtattuk ezeket az értékeket a felhasználó számára.
Most számoljuk ki a csoport között megosztott cukorkák teljes számát. Ez nem nagyon fontos.
7.2. példa:
Az egy főre jutó cukorkák számát megszorozzuk az evők számával.
Kód:
# 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)
Kimenet:
The total number of candies being shared among the group: 12
Magyarázat:
A fenti kódrészletben kiszámítottuk a csoport között megosztott cukorkák teljes számát úgy, hogy az egy főre jutó cukorkák számát megszoroztuk az evők számával, és kinyomtattuk a kapott értéket a felhasználók számára.
A megosztott teljes cukorkák teljes száma 12 . A cukorkák teljes száma azonban az 13 . Ez a kijelentés arra utal, hogy egy cukorka megmarad, és nem fogjuk megenni.
tömb c karakterlánc
A fenti példa a maradékok számának kiszámításának egyik módját írja le. Ha azonban csak a maradékok száma érdekel, akkor a modulo segítségével közvetlenül kiszámolhatjuk.
7.3. példa:
Adott 13 cukorka és 4 evő, mennyi a maradék cukorka?
Kód:
# 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)
Kimenet:
Number of Candies: 13 Number of Eaters: 4 Total number of Leftover Candies: 1
Magyarázat:
A fenti kódrészletben deklaráltuk a cukorkák és evők értéket tároló változókat. Ezután kiszámítottuk a maradék cukorkák számát a % a modulo műveletet jelző operátor. Végre kinyomtattunk néhány utasítást és eredményértéket a felhasználók számára. Ennek eredményeként láthatjuk, hogy a maradék cukorka az 1 .
a = b * (a // b) + (a % b)
A Pythonban a padlófelosztás és a modulo a következő egyenlettel függ össze:
Ahol:
Például ellenőrizzük, hogy a fenti egyenlet érvényes a 13 cukorkára és 4 evőre.
13 = 4 * (13 // 4) + (13% 4)
13 = 4 * 3 + 1
13 = 13
Így megértettük a padlóosztás és a modulo fogalmát a Pythonban. Most megnézünk néhány beépített függvényt, amely mindkettőt kiszámítja.
A divmod() függvény megértése Pythonban
A Python egy beépített függvényt kínál, az úgynevezett divmod() Ez lehetővé teszi, hogy kiszámoljuk az emeletosztást és a modulo-t két numerikus érték között.
A szintaxis a divmod() funkció az alábbiakban látható:
Szintaxis:
res = divmod(var_1, var_2)
Ahol:
Nézzük most a következő példát, amely bemutatja a divmod() funkció.
8. példa:
Adott 13 cukorka és 4 evő, hány teljes cukorkát kap minden evő, és hány cukorka maradt?
Kód:
# 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)
Kimenet:
Number of Candies: 13 Number of Eaters: 4 Number of Candies per eater: 3 Total number of Leftover Candies: 1
Magyarázat:
A fenti kódrészletben deklaráltunk néhány változót. Használtuk a divmod() függvény a padlóosztás értékének és a modulo kiszámításához az adott változókhoz. Ezután ezeket az értékeket kinyomtattuk a felhasználók számára.
A padlófelosztás elsőbbségének megértése
Pythonban, a padlóosztás operátora // hasonló elsőbbségi szinttel rendelkezik, mint a szorzás ( * ), osztály ( / ), és modulo ( % ).
Ez az állítás arra utal, hogy ha szorozunk, majd osztunk, akkor először a szorzás történik, majd az emeletosztás és fordítva.
Ha azonban például kivonunk két számot, majd végrehajtjuk az emeletosztást, a padlóosztási művelet kikövezi az utat.
Nézzünk egy példát, amely ugyanezt bizonyítja.
9.1. példa:
# 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)
Kimenet:
3 * 5 // 6 - 7 = -5
Magyarázat:
A fenti kódrészletben néhány változót így deklaráltunk a = 3, b = 5, c = 6 , és d = 7 . Ezután végrehajtottunk egy műveletet, és az eredményt egy új változóban tároltuk, Ez . Végre kinyomtattuk ezt az értéket a felhasználók számára.
Az eredmény kiszámításának megértéséhez zárójelet illeszthetünk a kifejezések köré a megfelelő sorrendben.
Az alábbi példa ugyanezt ábrázolja:
9.2. példa:
# 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)
Kimenet:
(( 3 * 5 ) // 6 ) - 7 = -5
Magyarázat:
A fenti kódrészletben néhány változót így deklaráltunk a = 3, b = 5, c = 6 , és d = 7 . Ezután elvégeztük ugyanazt a műveletet, de zárójelben, és az eredményül kapott értéket egy új változóban tároltuk, Ez . Végre kinyomtattuk ezt az értéket a felhasználók számára.
Mint látható, az előző példához hasonló eredményt kapunk, ami azt jelenti, hogy a számítási sorrend a következő:
Szorzás → Szintosztás → Kivonás
Íme a fentiek lépésenkénti számítása:
3 * 5 // 6-7
((3 * 5) // 6) - 7
(15 // 6) - 7
2-7
-5
Megfelelően megértettük a padlófelosztást és annak használatát a Python programozási nyelvben.
Végezetül megvizsgálunk egy speciális használati esetet a padlófelosztáshoz. A következő esetben a haladó nem jelent keményet; azonban meglehetősen szokatlan.
A padlófelosztás előzetes használatának megértése
Néhányan tisztában lehetnek azzal, hogy egyéni objektumokat is készíthetünk, amelyek támogatják a Python padlóosztási műveletét. Ez egy speciális módszerrel lehetséges __floordiv__() .
A __floordiv__() metódus a Pythonban
A Python padlóosztási művelete két szám elosztására szolgál, és az eredményt a legközelebbi egész számra kerekíti.
A motorháztető alatt működik, mert a numerikus típus egy speciális, úgynevezett módszert valósít meg __floordiv__() . Aztán, amikor hívjuk a // operátor két objektum között, a __floordiv__() módszert hívják meg.
Pythonban közvetlenül is hívhatjuk a __floordiv__() módszer. Tekintsük a következő példát, amely ugyanezt mutatja be:
10. példa:
programozás c tömbökben
# 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)
Kimenet:
Using the // operator: 31 // 7 = 4 Using the __floordiv__() method: ( 31 ).__floordiv__( 7 ) = 4
Magyarázat:
A fenti kódrészletben két változót deklaráltunk mint a = 31 és b = 7 . Ezután padlóosztást végeztünk a // operátor és __floordiv__() módszerrel, és az eredő értékeit két változóban tárolták, c és d . Végre kinyomtattuk az eredményeket a felhasználók számára.
A fent látható kimenetből megfigyelhetjük, hogy mindkét kifejezés ugyanazt az eredményt adta. Ennek az az oka, hogy az első kifejezés a második kifejezéssé alakul. Más szóval, ezek a hívások egyenértékűek egymással.
Most a dolgok érdekesek lesznek. Tekintsük a következő példát.
11.1. példa:
A következő példában létrehozunk egy egyéni osztályt, amely az egész értékeket karakterláncként reprezentálja. Ezután létrehozunk két objektumot ebből az egyéni osztályból, és végrehajtjuk rajtuk az emeletosztási műveletet.
Kód:
# 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)
Kimenet:
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'
Magyarázat:
A fenti kódrészletben egy osztályt a következőképpen határoztunk meg IntStr amely az egész értékeket karakterláncként jeleníti meg. Ezután létrehoztunk két objektumot a IntStr osztály. Végre megvan a padló-osztás intonál tárgy által a intTwo objektumot, és megpróbálta kinyomtatni az eredményt.
A fenti kimenet azonban a TypeError . Ebből a hibaüzenetből kiderül IntStr az objektumok nem támogatják a padlófelosztást. Ennek a hibának van értelme. Hogyan lenne az egyéni típusnak nyoma az emeletelválasztó karakterlánc objektumokról?
Azonban, mint kiderült, elkészíthetjük a IntStr tárgytámasz padlóosztás.
Korábban megtanultuk, amikor felhívtuk a // operátor, hívjuk a __floordiv__() módszer. Ez a metódus valahol az objektum osztályában kerül végrehajtásra. Például az int objektumok támogatják a padlóosztást, mert az int osztály alkalmazta a __floordiv__() módszer.
Ezek a speciális módszerek, mint pl __floordiv__() , van valami elképesztő közös tulajdonsága, hogy ezeket a metódusokat implementálhatjuk az egyéni osztályba. Más szóval, az egyéni objektumokat a Python programozási nyelvben támogashatjuk a padlófelosztással.
Nézzük most a következő példát, amely ugyanezt mutatja be.
11.2. példa:
A következő példában megvalósítjuk a __floordiv__() módszerrel a IntStr osztály. Ezután létrehozunk két objektumot ebből az egyéni osztályból, és végrehajtjuk rajtuk az emeletosztási műveletet.
Kód:
# 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)
Kimenet:
17 // 4 = 4
Magyarázat:
A fenti kódrészletben egy osztályt a következőképpen határoztunk meg IntStr amely az egész értékeket karakterláncként jeleníti meg. Meg is valósítottuk a __floordiv__() módszer ezen az osztályon belül. Ez a metódus elfogadja a numerikus karakterlánc értékét önmagától és egy másik objektumtól. Ezeket a karakterlánc-értékeket egész számokká konvertáltuk, és emeletosztást hajtottunk végre közöttük. Ezután az eredményt visszaalakítottuk egy karakterláncra, és létrehoztunk egy újat IntStr tárgy. Példányosítottuk a IntStr osztályt két tárggyal, és padlóosztási műveletet hajtott végre közöttük. Végül kinyomtattuk a kapott értéket a felhasználók számára.
Most, hogy sikeresen megértettük az egyéni osztály létrehozásának módszerét a padlóosztás támogatására.
Ha nem tetszik, hogy hívnunk kell tárgy.val hogy lássuk az eredményt, megvalósíthatjuk a __str__() módszer, amely közvetlenül adja vissza az értéket nyomtatás közben.
Tekintsük a következő példát, amely ugyanezt mutatja be.
11.3. példa:
# 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)
Kimenet:
17 // 4 = 4
Magyarázat:
A fenti kódrészletben egy osztályt a következőképpen határoztunk meg IntStr amely az egész értékeket karakterláncként jeleníti meg. Meg is valósítottuk a __floordiv__() módszer ezen az osztályon belül. Ezután meghatároztuk a __str__() módszer, amely közvetlenül adja vissza a karakterlánc-értékeket nyomtatás közben. Példányosítottuk a IntStr osztályt két tárggyal, és padlóosztási műveletet hajtott végre közöttük. Végül kinyomtattuk a kapott értéket a felhasználók számára.