Nākamajā apmācībā mēs uzzināsim par Floor Division darbību, izmantojot Python programmēšanas valodu.

Bet pirms sākam, īsi sapratīsim, kas ir grīdu sadalījums.

Izpratne par grīdas iedalījumu

Stāvu dalīšana ir parasta dalīšanas darbība, izņemot to, ka tā atgriež lielāko iespējamo veselo skaitli. Šis veselais skaitlis var būt mazāks par parasto dalījuma izvadi vai vienāds ar to.

Grīdas funkcija matemātiskā izteiksmē tiek apzīmēta ar simbolu ⌊ ⌋.

Ļaujiet mums tagad saprast, kā darbojas grīdas nodaļas darbība. Piemēram,

⌊36/5⌋

1. darbība: Vispirms veic sadalīšanu. Mēs sadalīsim 36 autors 5 .

36 ÷ 5 = 7,2

2. darbība: Tagad mēs veiksim grīdas funkciju ar vērtību, ko iegūstam pēc dalīšanas, t.i., 7.2 .

⌊7,2⌋=7

Rezultātā mēs iegūstam 7 kas ir minimālā vērtība 7.2 . Tādējādi grīdas dalīšana nozīmē dalīšanu un noapaļošanu uz leju līdz tuvākajam veselam skaitlim.

Dažādas programmēšanas valodas piedāvā īpašu iebūvētu funkciju vai operatoru, lai aprēķinātu grīdas sadalījumu. Daži piemēri var būt:

1. Mēs varam izmantot stāvs () metode C++ programmēšanas valodā.
2. Mēs varam izmantot stāvs () metode Java programmēšanas valodā.
3. Mēs varam izmantot // operators Python programmēšanas valodā.

Tomēr mēs apspriedīsim tikai grīdas dalīšanas operācijas izmantošanu Python ar palīdzību dubultās slīpsvītras (//) operators .

Izpratne par stāvu sadalījumu, izmantojot Python

Python programmēšanas valodā grīdas dalīšana tiek izmantota, lai sadalītu divus skaitļus un noapaļotu rezultātu līdz tuvākajam veselam skaitlim.

Pirms iedziļināties grīdu dalīšanas jēdzienā, īsi atgādināsim sev par dalīšanas nozīmi un sistēmas darbību. math.floor() funkcija Python.

Regulāras dalīšanas veikšana Python

Mēs varam sadalīt divus skaitļus, izmantojot slīpsvītru ( / ) nodaļas operators Python. Apskatīsim šādu piemēru, kas parāda to pašu:

1. piemērs:

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

Izvade:

 13 / 4 = 3.25 

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam definējuši divus mainīgos kā a = 13 un b = 4 . Pēc tam esam veikuši dalīšanas operāciju, izmantojot atpakaļvērsto slīpsvītru ( / ) sadalīšanas operatoru un saglabāja iegūto vērtību jaunā mainīgajā, c . Beidzot esam izdrukājuši vērtību c .

Kā redzam, dalīšana Python darbojas tāpat kā dalīšana matemātikā.

q4 mēneši

Funkcijas math.floor() izpratne programmā Python

Python ir iebūvēts matemātikas modulis, kas sastāv no dažādām noderīgām matemātiskām utilītprogrammām aprēķiniem.

Viena no šādām iebūvētajām funkcijām matemātika modulis ir math.floor() funkciju. Šī funkcija pieņem ciparu ievadi un atgriež zemāko vērtību, noapaļojot to uz leju līdz tuvākajam veselam skaitlim.

Apskatīsim šādu piemēru, kas parāda to pašu:

2. piemērs:

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

Izvade:

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

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam importējuši stāvs () funkcija no matemātika modulis. Pēc tam mēs esam deklarējuši divus mainīgos kā a = 5,34 un b = -5,34 . Pēc tam mēs izmantojām stāvs () funkcija, lai aprēķinātu abu mainīgo lielumu zemākās vērtības un saglabātu tos jaunos mainīgajos, c un d . Beidzot esam izdrukājuši rezultātus lietotājiem.

Tagad, kad esam sapratuši Python dalīšanas un grīdas skaitļu jēdzienus. Ļaujiet mums pievērsties detaļām, kas saistītas ar stāvu sadalījumu Python.

Stāvu nodaļas veikšana programmā Python

Stāvu dalīšana ir Python darbība, kas ļauj sadalīt divus skaitļus un noapaļo iegūto vērtību līdz tuvākajam veselam skaitlim. Grīdas dalījums notiek caur dubultās slīpsvītras (//) operators . Tā paša sintakse ir parādīta zemāk:

Sintakse:

 res = var_1 // var_2 

Kur:

resir grīdas dalījuma rezultējošā vērtībabija_1ir dividendebija_2ir dalītājs

Grīdas dalījumu varam uzskatīt par parasto dalījumu apvienojumā ar math.floor() funkciju izsaukums.

Piezīme. Grīdas dalījums var noapaļot jebkuru skaitli uz leju līdz tuvākajam veselam skaitlim. Piemēram, 3,99 joprojām tiks noapaļoti uz leju līdz 3.

Tagad apskatīsim piemēru, kas parāda grīdas dalīšanas darbību.

3. piemērs:

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

Izvade:

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

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam deklarējuši divus mainīgos kā a = 13 un b = 5 . Pēc tam mēs izmantojām // operatoram, lai aprēķinātu grīdas iedalījuma vērtību un saglabātu zemākās vērtības vērtību jaunā mainīgajā, c . Pēc tam esam veikuši regulāro dalīšanu, izmantojot / operatoru un saglabāja vērtību citā mainīgajā, d . Beidzot esam izdrukājuši gan rezultātus, gan tos salīdzinājuši.

Tagad aplūkosim citu piemēru, izmantojot math.floor() funkciju.

4. piemērs:

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

Izvade:

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

Paskaidrojums:

Mēs esam importējuši stāvs () funkcija no matemātika modulis iepriekš minētajā koda fragmentā. Pēc tam mēs esam deklarējuši divus mainīgos kā a = 17 un b = 5 . Pēc tam mēs izmantojām stāvs () funkcija, sadalīta a autors b , un saglabāja to mainīgajā c. Pēc tam esam aprēķinājuši zemāko vērtību, izmantojot // operatoru un saglabāja vērtību jaunā mainīgā, d . Beidzot esam izdrukājuši abas vērtības un salīdzinājušas tās.

Stāvu dalīšanas veikšana ar negatīviem skaitļiem

Mēs varam arī veikt grīdas dalīšanu, izmantojot negatīvus skaitļus.

Negatīvu skaitļu gadījumā iegūtā vērtība joprojām tiek noapaļota uz leju līdz tuvākajam veselam skaitlim. Dažus var apjukt, noapaļojot negatīvu skaitli uz leju, tas nozīmē atkāpšanos no nulles. Piemēram, -23 ir grīdas līdz -3 .

Apskatīsim piemēru, kas parāda stāvu dalījumu ar negatīviem skaitļiem.

5. piemērs:

 # declaring the variables a = -10 b = 4 # calculating floor value using // operator c = a // b # printing the value print('Floor Division:', a, '//', b, '=', c) 

Izvade:

 Floor Division: -10 // 4 = -3 

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam deklarējuši divus mainīgos kā a = -10 un b = 4 . Pēc tam mēs izmantojām // operatoram, lai aprēķinātu zemāko vērtību un saglabātu to jaunā mainīgajā, c . Beidzot esam izdrukājuši lietotāja vērtību.

Ar regulāru sadalījumu, -10/4 atgrieztos -2.5 ; tomēr ar grīdas dalījumu šis skaitlis ir noapaļots uz leju līdz tuvākajam negatīvajam veselam skaitlim, t.i., līdz -3 .

Grīdas nodaļas veikšana ar pludiņiem

Mēs varam arī veikt Floor dalīšanu ar pludiņiem Python. Ja grīdas dalīšanas peldlīdzekļi tiek sadalīti, rezultāts ir pludiņš, kas attēlo tuvāko veselo skaitli.

Apskatīsim šādu piemēru, kas parāda grīdas sadalījumu, izmantojot pludiņus.

6. piemērs:

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

Izvade:

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

Paskaidrojums:

Linux kura komanda

Iepriekš minētajā koda fragmentā esam inicializējuši divus sarakstus. Pēc tam mēs izmantojām priekš -cilpa, lai atkārtotu šo sarakstu elementus, aprēķinātu vērtības katrai stāvu sadalīšanas darbībai un izdrukātu rezultātus lietotājiem.

Rezultātā mēs varam novērot, ka grīdas dalīšanas darbība tiek veikta, izmantojot pludiņus, un pludiņš ar veselu skaitli atgriež vērtību, noapaļojot uz leju līdz tuvākajam veselam skaitlim, kas attēlots kā pludiņi.

Grīdas nodaļa un Modulo programmā Python

Matemātikā modulo ir jēdziens, kas galvenokārt saistīts ar grīdas dalīšanu. Mēs varam arī teikt, ka modulo nozīmē atlikumu sadalījumā starp diviem skaitļiem. Citiem vārdiem sakot, ar to mēs varam saskaitīt pārpalikumu skaitu.

Mēs varam aprēķināt modulo Python, izmantojot procentus ( % ) operators.

Apskatīsim piemēru, kas ilustrē attiecības starp grīdas dalījumu un modulo Python.

7.1. piemērs:

Ņemot vērā 13 konfektes un 4 ēdājus, mēs varam aprēķināt katra ēdāja konfekšu skaitu ar grīdas dalījuma palīdzību.

Kods:

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

Izvade:

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

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam deklarējuši dažus mainīgos lielumus, kas apzīmē konfekšu un ēdāju skaitu. Pēc tam mēs izmantojām // operatoram jāveic stāvu dalīšana, lai aprēķinātu, cik konfekšu saņem katrs ēdājs. Pēc tam esam izdrukājuši šīs vērtības lietotājam.

Tagad aprēķināsim kopējo konfekšu skaitu, kas tika sadalītas grupā. Tas nav ļoti svarīgi.

7.2. piemērs:

Konfekšu skaitu uz vienu cilvēku reiziināsim ar ēdāju skaitu.

Kods:

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

Izvade:

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

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam aprēķinājuši kopējo konfekšu skaitu, kas tiek dalītas starp grupu, reizinot konfekšu skaitu uz vienu personu ar ēdāju skaitu, un izdrukājām iegūto vērtību lietotājiem.

Kopējais izdalīto pilno konfekšu skaits ir 12 . Tomēr kopējais konfekšu skaits ir 13 . Šis apgalvojums nozīmē, ka viena konfekte būs pāri un netiks ēsta.

Iepriekš minētajā piemērā ir aprakstīts viens veids, kā aprēķināt atlikumu skaitu. Taču, ja mūs interesē tikai pārpalikumu skaits, varam to tieši aprēķināt ar modulo palīdzību.

7.3. piemērs:

Ņemot vērā 13 konfektes un 4 ēdājus, kāds ir konfekšu atlikumu skaits?

Kods:

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

Izvade:

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

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam deklarējuši mainīgos lielumus, kas glabā vērtību konfektes un ēdāji. Pēc tam mēs esam aprēķinājuši atlikušo konfekšu skaitu, izmantojot % operators, kas apzīmē modulo darbību. Beidzot mēs esam izdrukājuši dažus paziņojumus un izrietošās vērtības lietotājiem. Rezultātā redzam, ka pāri palikušās konfektes ir 1 .

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

Programmā Python grīdas dalījums un modulis ir saistīti ar šādu vienādojumu:

Kur:

air dividende.bir dalītājs.

Piemēram, pārbaudīsim, vai iepriekšminētais vienādojums attiecas uz 13 konfektēm un 4 ēdājiem.

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

Tādējādi mēs esam sapratuši Python grīdas dalīšanas un modulo jēdzienus. Tagad mēs apskatīsim dažas iebūvētās funkcijas, kas aprēķina abus.

Izpratne par divmod() funkciju Python

Python piedāvā iebūvētu funkciju, ko sauc divmod () kas ļauj mums aprēķināt gan grīdas sadalījumu, gan moduli starp divām skaitliskām vērtībām.

treknrakstā CSS

Sintakse divmod () funkcija ir parādīta zemāk:

Sintakse:

 res = divmod(var_1, var_2) 

Kur:

resir rezultāts kā kortežs. Šajā kortežā ir grīdas dalījuma rezultāts un atlikums, ko dod modulo.bija_1ir dividende.bija_2ir dalītājs.

Tagad apskatīsim šādu piemēru, kas parāda divmod () funkciju.

8. piemērs:

Ņemot vērā 13 konfektes un 4 ēdājus, cik pilnas konfektes saņem katrs ēdājs un cik konfekšu paliek?

Kods:

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

Izvade:

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

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam deklarējuši dažus mainīgos. Mēs esam izmantojuši divmod () funkcija, lai aprēķinātu grīdas dalījuma vērtību un moduli dotajiem mainīgajiem. Mēs esam izdrukājuši šīs vērtības lietotājiem.

Izpratne par grīdu sadalījuma prioritāti

Python, stāvu dalīšanas operators // ir līdzīgs prioritātes līmenis kā reizināšanai ( * ), nodaļa ( / ), un modulo ( % ).

Šis apgalvojums nozīmē, ka, ja mēs reizinām un pēc tam dalām ar grīdu, vispirms tiek panākta reizināšana, pēc tam grīdas dalīšana un otrādi.

Tomēr, ja mēs, piemēram, atņemam divus skaitļus un pēc tam veiksim grīdas dalīšanu, grīdas dalīšanas darbība pavērs ceļu.

Apskatīsim piemēru, kas parāda to pašu.

9.1. piemērs:

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

Izvade:

 3 * 5 // 6 - 7 = -5 

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam deklarējuši dažus mainīgos kā a = 3, b = 5, c = 6 , un d = 7 . Pēc tam mēs esam veikuši darbību un saglabājuši iegūto vērtību jaunā mainīgajā, Tas ir . Beidzot mēs esam izdrukājuši šo vērtību lietotājiem.

Lai saprastu, kā šis rezultāts tiek aprēķināts, mēs varam ievietot iekavas ap terminiem pareizā prioritātes secībā.

Tālāk redzamais piemērs parāda to pašu:

9.2. piemērs:

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

Izvade:

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

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam deklarējuši dažus mainīgos kā a = 3, b = 5, c = 6 , un d = 7 . Pēc tam mēs esam veikuši to pašu darbību, bet ar iekavām un saglabājām iegūto vērtību jaunā mainīgajā, Tas ir . Beidzot mēs esam izdrukājuši šo vērtību lietotājiem.

Kā redzam, mēs iegūstam līdzīgu rezultātu kā iepriekšējā piemērā, kas nozīmē, ka aprēķina secība ir šāda:

Reizināšana → Grīdas dalīšana → Atņemšana

Šeit ir pakāpenisks iepriekšminētā aprēķins:

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

Mēs esam pareizi sapratuši grīdas sadalījumu un tā izmantošanu Python programmēšanas valodā.

Visbeidzot, mēs aplūkosim grīdas sadalījuma uzlabotas lietošanas gadījumu. Tālāk norādītajā gadījumā, uzlabots nenozīmē grūti; tomēr tas ir diezgan neparasti.

Izpratne par grīdas nodaļas iepriekšēju izmantošanu

Daži no mums, iespējams, zina, ka mēs varam izveidot arī pielāgotus objektus, kas atbalsta grīdas dalīšanas darbību Python. To var izdarīt, izmantojot īpašu metodi, kas pazīstama kā __floordiv__() .

Metode __floordiv__() programmā Python

Grīdas dalīšanas darbība Python tiek izmantota, lai sadalītu divus skaitļus un noapaļotu rezultātu līdz tuvākajam veselam skaitlim.

Tas darbojas zem pārsega, jo ciparu tips ievieš īpašu metodi, ko sauc __floordiv__() . Tad ikreiz, kad mēs zvanām // operators starp diviem objektiem, __floordiv__() metode tiek izsaukta.

Python mēs varam arī tieši izsaukt __floordiv__() metodi. Apskatīsim šādu piemēru, kas parāda to pašu:

10. piemērs:

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

Izvade:

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

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam deklarējuši divus mainīgos kā a = 31 un b = 7 . Pēc tam mēs veicām grīdas sadalīšanu, izmantojot // operators un __floordiv__() metodi un saglabāja to iegūtās vērtības divos mainīgajos, c un d . Beidzot esam izdrukājuši rezultātus lietotājiem.

No iepriekš parādītās izvades mēs varam novērot, ka abas izteiksmes ir devušas vienādu rezultātu. Tas ir tāpēc, ka pirmā izteiksme tiek pārveidota par otro izteiksmi. Citiem vārdiem sakot, šie zvani ir līdzvērtīgi viens otram.

Tagad lietas kļūs interesantas. Apskatīsim šādu piemēru.

11.1. piemērs:

sql concat

Mēs izveidosim pielāgotu klasi, kas attēlo veselu skaitļu vērtības kā virknes nākamajā piemērā. Pēc tam mēs izveidosim divus šīs pielāgotās klases objektus un veiksim tiem grīdas sadalīšanas darbību.

Kods:

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

Izvade:

 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' 

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam definējuši klasi kā IntStr kas attēlo veselu skaitļu vērtības kā virknes. Pēc tam esam izveidojuši divus objektus IntStr klasē. Beidzot mums ir grīdas sadalījums intOne objekts ar intTwo objektu un mēģināja izdrukāt rezultātu.

Tomēr iepriekš minētā izvade norāda a Tipa kļūda . Šis kļūdas ziņojums to atklāj IntStr objekti neatbalsta grīdas sadalījumu. Šai kļūdai ir jēga. Kā pielāgotajam tipam būtu kāda nojausma par stāvu sadalošo virkņu objektiem?

Tomēr, kā izrādās, mēs varam veikt IntStr objektu atbalsta grīdas sadalījums.

Iepriekš mēs mācījāmies ikreiz, kad zvanījām // operators, mēs saucam __floordiv__() metodi. Šī metode tiek izpildīta kaut kur objekta klasē. Piemēram, int objekti atbalsta grīdas dalīšanu, jo int klase ir lietojusi __floordiv__() metodi.

Šīs īpašās metodes, piemēram __floordiv__() , ir kaut kas pārsteidzošs kopīgs, ka mēs varam ieviest šīs metodes pielāgotajā klasē. Citiem vārdiem sakot, mēs varam likt pielāgotajiem objektiem atbalstīt grīdas dalīšanu Python programmēšanas valodā.

Tagad apskatīsim šādu piemēru, kas parāda to pašu.

11.2. piemērs:

Nākamajā piemērā mēs ieviesīsim __floordiv__() metodi IntStr klasē. Pēc tam mēs izveidosim divus šīs pielāgotās klases objektus un veiksim tiem grīdas sadalīšanas darbību.

Kods:

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

Izvade:

 17 // 4 = 4 

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam definējuši klasi kā IntStr kas attēlo veselu skaitļu vērtības kā virknes. Mēs esam arī ieviesuši __floordiv__() metode šajā klasē. Šī metode pieņem ciparu virknes vērtību no sevis un cita objekta. Mēs pārveidojām šīs virknes vērtības veselos skaitļos un veicām grīdas sadalījumu starp tām. Pēc tam mēs esam pārveidojuši rezultātu atpakaļ virknē un izveidojuši jaunu IntStr objektu. Mēs izveidojām momentu IntStr klasē ar diviem objektiem un veica stāvu sadalīšanas operāciju starp tiem. Beidzot mēs esam izdrukājuši iegūto vērtību lietotājiem.

Tagad, kad mēs veiksmīgi saprotam metodi, kā izveidot pielāgotu klasi, lai atbalstītu grīdas dalīšanu.

Ja mums nepatīk, ka jāzvana objekts.val lai redzētu rezultātu, mēs varam īstenot __str__() metode, kas tieši atgriež vērtību drukāšanas laikā.

Apskatīsim šādu piemēru, kas parāda to pašu.

11.3. piemērs:

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

Izvade:

 17 // 4 = 4 

Paskaidrojums:

Iepriekš minētajā koda fragmentā mēs esam definējuši klasi kā IntStr kas attēlo veselu skaitļu vērtības kā virknes. Mēs esam arī ieviesuši __floordiv__() metode šajā klasē. Pēc tam mēs esam definējuši __str__() metode, kas tieši atgriež virknes vērtības drukāšanas laikā. Mēs izveidojām momentu IntStr klasē ar diviem objektiem un veica stāvu sadalīšanas operāciju starp tiem. Beidzot mēs esam izdrukājuši iegūto vērtību lietotājiem.