TechCodeview

Seuraavassa opetusohjelmassa opimme Floor Divisionin toiminnasta Python-ohjelmointikielellä.

Mutta ennen kuin aloitamme, ymmärrämme lyhyesti, mikä Floor-jako on.

Lattia-jaon ymmärtäminen

Kerrosjako on normaali jakooperaatio, paitsi että se palauttaa suurimman mahdollisen kokonaisluvun. Tämä kokonaisluku voi olla pienempi kuin normaalijakotulos tai yhtä suuri kuin se.

Lattiafunktio on merkitty matemaattisesti symbolilla ⌊ ⌋.

Ymmärrämme nyt Floor-divisioonan toiminnan. Esimerkiksi,

⌊36/5⌋

Vaihe 1: Jako suoritetaan ensin. Me jaamme 36 kirjoittaja 5 .

36 ÷ 5 = 7,2

Vaihe 2: Nyt suoritamme lattiafunktion arvolle, jonka saamme jaon jälkeen, eli 7.2 .

⌊7,2⌋=7

Tuloksena saamme 7 joka on pohja-arvo 7.2 . Näin ollen kerrosjako tarkoittaa jakamista ja pyöristämistä alaspäin lähimpään kokonaislukuun.

Eri ohjelmointikielet tarjoavat tietyn sisäänrakennetun toiminnon tai operaattorin kerrosten jaon laskemiseksi. Joitakin esimerkkejä voivat olla:

1. Voimme käyttää lattia() menetelmä C++-ohjelmointikielellä.
2. Voimme käyttää lattia() menetelmä Java-ohjelmointikielellä.
3. Voimme käyttää // operaattori Python-ohjelmointikielellä.

Keskustelemme kuitenkin vain Pythonin lattiajakotoiminnon käytöstä kaksoiskenoviiva (//) -operaattori .

Floor Divisionin ymmärtäminen Pythonilla

Python-ohjelmointikielessä kerrosjakoa käytetään jakamaan kaksi lukua ja pyöristämään tulos alaspäin lähimpään kokonaislukuun.

Ennen kuin sukeltaamme syvemmälle lattiajaon käsitteeseen, muistuttakaamme lyhyesti jaon merkityksestä ja sen toiminnasta. math.floor() toiminto Pythonissa.

Suorittaa säännöllisen jaon Pythonissa

Voimme jakaa kaksi lukua kenoviivalla ( / ) jakooperaattori Pythonissa. Tarkastellaan seuraavaa esimerkkiä, joka osoittaa saman:

Esimerkki 1:

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

Lähtö:

 13 / 4 = 3.25 

Selitys:

Yllä olevassa koodinpätkässä olemme määrittäneet kaksi muuttujaa muodossa a = 13 ja b = 4 . Olemme sitten suorittaneet jakotoiminnon kenoviivalla ( / ) jakooperaattori ja tallensi tuloksena olevan arvon uuteen muuttujaan, c . Viimeinkin olemme tulostaneet arvon c .

Kuten näemme, Pythonissa jako toimii samalla tavalla kuin jako toimii matematiikassa.

Pythonin math.floor()-funktion ymmärtäminen

Pythonissa on sisäänrakennettu matemaattinen moduuli, joka koostuu erilaisista hyödyllisistä matemaattisista apuohjelmista laskelmia varten.

Yksi tällainen sisäänrakennettu toiminto matematiikka moduuli on math.floor() toiminto. Tämä funktio hyväksyy numeerisen syötteen ja palauttaa pohjaarvon pyöristämällä sen alaspäin lähimpään kokonaislukuun.

Tarkastellaan seuraavaa esimerkkiä, joka osoittaa saman:

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

Lähtö:

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

Selitys:

Yllä olevassa koodinpätkässä olemme tuoneet lattia() toiminto alkaen matematiikka moduuli. Olemme sitten ilmoittaneet kaksi muuttujaa nimellä a = 5,34 ja b = -5,34 . Olemme sitten käyttäneet lattia() funktio laskea molempien muuttujien pohja-arvot ja tallentaa ne uusiin muuttujiin, c ja d . Viimeinkin olemme tulostaneet tulokset käyttäjille.

Nyt kun olemme ymmärtäneet jako- ja kerroslukujen käsitteet Pythonissa. Siirrytään Pythonin lattiajakoon liittyviin yksityiskohtiin.

Floor Divisionin suorittaminen Pythonissa

Lattiajako on Pythonin operaatio, jonka avulla voimme jakaa kaksi lukua ja pyöristää tuloksena olevan arvon alaspäin lähimpään kokonaislukuun. Lattiajako tapahtuu kautta kaksoiskenoviiva (//) -operaattori . Saman syntaksi näkyy alla:

bash lukea tiedosto

Syntaksi:

 res = var_1 // var_2 

Missä:

reson lattiajaon tuloksena saatu arvooli_1on osinkooli_2on jakaja

Voimme ajatella lattiajakoa säännöllisenä jaotuksena yhdistettynä math.floor() toimintokutsu.

Huomautus: Kerrosjako voi pyöristää minkä tahansa luvun alaspäin lähimpään kokonaislukuun. Esimerkiksi 3,99 pyöristetään edelleen alaspäin kolmeen.

Tarkastellaan nyt esimerkkiä lattiajaon toiminnasta.

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

Lähtö:

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

Selitys:

Yllä olevassa koodinpätkässä olemme ilmoittaneet kaksi muuttujaa nimellä a = 13 ja b = 5 . Olemme sitten käyttäneet // käyttäjä laskee kerrosjaon arvon ja tallentaa pohjaarvon uuteen muuttujaan, c . Tämän jälkeen olemme suorittaneet säännöllisen jaon käyttämällä / operaattori ja tallentanut arvon toiseen muuttujaan, d . Viimeinkin olemme tulostaneet molemmat tulokset ja vertailleet niitä.

Tarkastellaan nyt toista esimerkkiä käyttämällä math.floor() toiminto.

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

Lähtö:

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

Selitys:

Olemme tuoneet maahan lattia() toiminto alkaen matematiikka moduuli yllä olevassa koodinpätkässä. Olemme sitten ilmoittaneet kaksi muuttujaa nimellä a = 17 ja b = 5 . Käytimme sitten lattia() toiminto, jaettu a kirjoittaja b ja tallentanut sen muuttujaan c. Tämän jälkeen olemme laskeneet pohja-arvon käyttämällä // operaattori ja tallentanut arvon uuteen muuttujaan, d . Viimeinkin olemme tulostaneet molemmat arvot ja vertailleet niitä.

Suoritetaan kerrosjako negatiivisilla luvuilla

Voimme myös suorittaa kerrosten jaon käyttämällä negatiivisia lukuja.

Negatiivisten lukujen tapauksessa tuloksena oleva arvo pyöristetään edelleen alaspäin lähimpään kokonaislukuun. Jotkut saattavat hämmentyä pyöristämällä negatiivista lukua alaspäin, mikä merkitsee siirtymistä nollasta poispäin. Esimerkiksi, -23 on lattialla alaspäin -3 .

Tarkastellaan esimerkkiä, joka havainnollistaa kerrosten jakoa negatiivisilla luvuilla.

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

Lähtö:

 Floor Division: -10 // 4 = -3 

Selitys:

Yllä olevassa koodinpätkässä olemme ilmoittaneet kaksi muuttujaa nimellä a = -10 ja b = 4 . Olemme sitten käyttäneet // operaattori laskea alimman arvon ja tallentaa sen uuteen muuttujaan, c . Viimeinkin olemme tulostaneet arvon käyttäjälle.

Säännöllisen jaon kanssa -10/4 palaisi -2.5 ; kuitenkin kerrosjaolla tämä luku pyöristetään alaspäin lähimpään negatiiviseen kokonaislukuun, ts. -3 .

Floor Divisionin suorittaminen kellukkeiden kanssa

Pythonissa voimme myös suorittaa Floor-jaon floatilla. Kun lattian jakaminen kelluu, tulos on float, joka edustaa lähintä kokonaislukua.

Tarkastellaan seuraavaa esimerkkiä, joka havainnollistaa lattian jakamista kellukkeiden avulla.

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

Lähtö:

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

Selitys:

Yllä olevassa koodinpätkässä olemme alustaneet kaksi luetteloa. Olemme sitten käyttäneet varten -silmukan toistaaksesi näiden luetteloiden elementtejä, laskenut arvot jokaiselle kerrosjakotoiminnolle ja tulostaaksesi tulokset käyttäjille.

Tuloksena voidaan havaita, että kerrosjakooperaatio suoritetaan kellukkeiden avulla ja float kokonaisluvulla palauttaa arvon pyöristettynä alaspäin lähimpään kokonaislukuun, joka esitetään kellukkeina.

Floor Division ja Modulo Pythonissa

Matematiikassa modulo on käsite, joka liittyy pääasiassa kerrosjakoon. Voidaan myös sanoa, että modulo tarkoittaa jakojäännöstä kahden luvun välillä. Toisin sanoen voimme laskea sen avulla ylijäämien määrän.

Pythonissa modulo voidaan laskea käyttämällä prosenttiosuutta ( % ) -operaattori.

Tarkastellaan esimerkkiä, joka havainnollistaa lattiajaon ja modulon välistä suhdetta Pythonissa.

Esimerkki 7.1:

kuinka löytää piilotettuja sovelluksia Androidista

Kun otetaan huomioon 13 karkkia ja 4 syöjää, voimme laskea jokaisen syöjän saamien karkkien määrän kerrosjaon avulla.

Koodi:

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

Lähtö:

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

Selitys:

Yllä olevassa koodinpätkässä olemme ilmoittaneet joitain muuttujia, jotka ilmaisevat karkkien ja syöjien määrää. Olemme sitten käyttäneet // operaattori suorittaa kerrosten jaon laskeakseen kunkin syöjän saamien karkkien määrän. Olemme sitten tulostaneet nämä arvot käyttäjälle.

Lasketaan nyt ryhmän kesken jaettujen karkkien kokonaismäärä. Tämä ei ole kovin tärkeää.

Esimerkki 7.2:

Kerromme karkkien määrän per henkilö syöjien määrällä.

Koodi:

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

Lähtö:

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

Selitys:

Yllä olevassa koodinpätkässä olemme laskeneet ryhmän kesken jaettujen karkkien kokonaismäärän kertomalla karkkien määrän henkilöä kohden syöjien määrällä ja tulostanut tuloksena olevan arvon käyttäjille.

Jaettujen täysien karkkien kokonaismäärä on 12 . Kuitenkin karkkien kokonaismäärä on 13 . Tämä lausunto viittaa siihen, että yksi karkki jää yli, eikä sitä aiota syödä.

Yllä oleva esimerkki kuvaa yhtä tapaa laskea ylijäämien määrä. Jos olemme kuitenkin kiinnostuneita vain ylijäämien määrästä, voimme laskea sen suoraan modulon avulla.

Esimerkki 7.3:

Kun otetaan huomioon 13 karkkia ja 4 syöjää, kuinka monta karkkia on jäljellä?

Koodi:

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

Lähtö:

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

Selitys:

Yllä olevassa koodinpätkässä olemme ilmoittaneet muuttujat, jotka tallentavat arvon makeiset ja syöjät. Olemme sitten laskeneet jäljellä olevien karkkien määrän käyttämällä % operaattori, joka tarkoittaa modulo-toimintoa. Viimeinkin olemme tulostaneet käyttäjille joitain lausuntoja ja tuloksena olevia arvoja. Tuloksena voimme nähdä, että ylijäämä karkki on 1 .

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

Pythonissa kerrosjako ja modulo liittyvät toisiinsa seuraavalla yhtälöllä:

Missä:

aon osinko.bon jakaja.

Tarkastetaan esimerkiksi, että yllä oleva yhtälö pätee 13 karkkia ja 4 syöjää.

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

Näin ollen olemme ymmärtäneet Pythonissa lattiajaon ja modulon käsitteet. Nyt tarkastelemme joitain sisäänrakennettuja funktioita, jotka laskevat molemmat.

Divmod()-funktion ymmärtäminen Pythonissa

Python tarjoaa sisäänrakennetun toiminnon nimeltä divmod() jonka avulla voimme laskea sekä kerrosjaon että modulon kahden numeerisen arvon välillä.

Syntaksi kohteelle divmod() toiminto näkyy alla:

Syntaksi:

 res = divmod(var_1, var_2) 

Missä:

reson tulos monikkona. Tällä monitolla on kerrosjaon tulos ja loput modulon antama.oli_1on osinko.oli_2on jakaja.

Tarkastellaan nyt seuraavaa esimerkkiä, joka osoittaa divmod() toiminto.

Esimerkki 8:

Kun annetaan 13 karkkia ja 4 syöjää, kuinka monta täyttä karkkia kukin syöjä saa ja kuinka monta karkkia on jäljellä?

Koodi:

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

Lähtö:

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

Selitys:

valitse nimellä

Yllä olevassa koodinpätkässä olemme ilmoittaneet joitain muuttujia. Olemme käyttäneet divmod() funktio laskea kerrosjaon arvo ja modulo annetuille muuttujille. Olemme sitten tulostaneet nämä arvot käyttäjille.

Lattiajaon tärkeysjärjestyksen ymmärtäminen

Pythonissa, lattiajaon operaattori // on samanlainen prioriteettitaso kuin kertolasku ( * ), jako ( / ), ja modulo ( % ).

Tämä väite viittaa siihen, että jos kerromme ja sitten kerromme, saadaan ensin kertolasku ja sitten kerrosjako ja päinvastoin.

Kuitenkin, jos esimerkiksi vähennämme kaksi lukua ja teemme sitten kerrosten jakamisen, kerrosten jakotoiminto tasoittaa tietä.

Tarkastellaanpa esimerkkiä, joka osoittaa saman.

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

Lähtö:

 3 * 5 // 6 - 7 = -5 

Selitys:

Yllä olevassa koodinpätkässä olemme ilmoittaneet jotkin muuttujat muodossa a = 3, b = 5, c = 6 , ja d = 7 . Olemme sitten suorittaneet toiminnon ja tallentaneet tuloksena olevan arvon uuteen muuttujaan, se on . Viimeinkin olemme tulostaneet tämän arvon käyttäjille.

Ymmärtääksemme, kuinka tämä tulos lasketaan, voimme lisätä termien ympärille sulut oikeassa tärkeysjärjestyksessä.

Alla oleva esimerkki kuvaa samaa:

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

Lähtö:

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

Selitys:

Yllä olevassa koodinpätkässä olemme ilmoittaneet jotkin muuttujat muodossa a = 3, b = 5, c = 6 , ja d = 7 . Sitten olemme suorittaneet saman toiminnon, mutta suluilla ja tallentaneet tuloksena olevan arvon uuteen muuttujaan, se on . Viimeinkin olemme tulostaneet tämän arvon käyttäjille.

Kuten voimme havaita, että saamme samanlaisen tuloksen kuin edellisestä esimerkistä, mikä tarkoittaa, että laskentajärjestys on:

Kertominen → Pohjajako → Vähennys

Tässä on vaiheittainen laskelma yllä olevasta:

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

Olemme ymmärtäneet lattiajaon oikein ja sen käytön Python-ohjelmointikielessä.

Lopuksi tarkastellaan lattiajaon edistyksellistä käyttöä. Seuraavassa tapauksessa edistynyt ei tarkoita kovaa; se on kuitenkin melko epätavallista.

Lattiaosion ennakkokäytön ymmärtäminen

Jotkut meistä saattavat olla tietoisia, että voimme myös tehdä mukautettuja objekteja, jotka tukevat Pythonin lattiajakotoimintoa. Tämä voi olla mahdollista erityisellä menetelmällä, joka tunnetaan ns __floordiv__() .

__floordiv__()-metodi Pythonissa

Pythonin kerrosjakooperaatiota käytetään kahden luvun jakamiseen ja tuloksen pyöristäminen alaspäin lähimpään kokonaislukuun.

Se toimii konepellin alla, koska numeerinen tyyppi toteuttaa erityisen menetelmän nimeltä __floordiv__() . Sitten aina kun soitamme // operaattori kahden objektin välillä __floordiv__() menetelmää kutsutaan.

Pythonissa voimme myös kutsua suoraan __floordiv__() menetelmä. Tarkastellaan seuraavaa esimerkkiä, joka osoittaa saman:

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

Lähtö:

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

Selitys:

Yllä olevassa koodinpätkässä olemme ilmoittaneet kaksi muuttujaa nimellä a = 31 ja b = 7 . Sitten teimme lattian jaon käyttämällä // operaattori ja __floordiv__() menetelmää ja tallentavat tuloksensa kahteen muuttujaan, c ja d . Viimeinkin olemme tulostaneet tulokset käyttäjille.

Yllä esitetystä tuloksesta voimme havaita, että molemmat lausekkeet ovat tuottaneet saman tuloksen. Tämä johtuu siitä, että ensimmäinen lauseke muunnetaan toiseksi lausekkeeksi. Toisin sanoen nämä puhelut vastaavat toisiaan.

Nyt asiat muuttuvat mielenkiintoisiksi. Tarkastellaanpa seuraavaa esimerkkiä.

Esimerkki 11.1:

Luomme mukautetun luokan, joka edustaa kokonaislukuarvoja merkkijonoina seuraavassa esimerkissä. Luomme sitten kaksi tämän mukautetun luokan objektia ja suoritamme niille kerrosten jakamisen.

Koodi:

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

Lähtö:

javan viipalointi

 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' 

Selitys:

Yllä olevassa koodinpätkässä olemme määrittäneet luokan muodossa IntStr joka edustaa kokonaislukuarvot merkkijonoina. Olemme sitten luoneet kaksi objektia IntStr luokkaa. Viimeinkin meillä on lattia-jako messuta esine, jonka intTwo ja yritti tulostaa tuloksen.

Yllä oleva tulos kuitenkin osoittaa a Tyyppivirhe . Tämä virheilmoitus paljastaa sen IntStr esineet eivät tue kerrosten jakoa. Tämä virhe on järkevä. Miten mukautetulla tyypillä olisi aavistustakaan lattianjakomerkkijonoista?

Kuitenkin, kuten käy ilmi, voimme tehdä IntStr esinetukilattian jako.

Aiemmin opimme aina, kun soitimme // operaattori, soitamme __floordiv__() menetelmä. Tämä menetelmä suoritetaan jossain objektin luokassa. Esimerkiksi int-objektit tukevat kerrosjakoa, koska int-luokka on soveltanut __floordiv__() menetelmä.

Nämä erikoismenetelmät, kuten __floordiv__() , joilla on jotain hämmästyttävää yhteistä, että voimme toteuttaa nämä menetelmät mukautettuun luokkaan. Toisin sanoen voimme saada mukautetut objektit tukemaan lattiajakoa Python-ohjelmointikielellä.

Tarkastellaan nyt seuraavaa esimerkkiä, joka osoittaa saman.

Esimerkki 11.2:

Seuraavassa esimerkissä toteutamme __floordiv__() menetelmä osaksi IntStr luokkaa. Luomme sitten kaksi tämän mukautetun luokan objektia ja suoritamme niille kerrosten jakamisen.

Koodi:

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

Lähtö:

 17 // 4 = 4 

Selitys:

Yllä olevassa koodinpätkässä olemme määrittäneet luokan muodossa IntStr joka edustaa kokonaislukuarvot merkkijonoina. Olemme myös toteuttaneet __floordiv__() menetelmä tässä luokassa. Tämä menetelmä hyväksyy numeerisen merkkijonon arvon itsestään ja toisesta objektista. Muunsimme nämä merkkijonoarvot kokonaisluvuiksi ja teimme kerrosjaon niiden välillä. Olemme sitten muuntaneet tuloksen takaisin merkkijonoksi ja luoneet uuden IntStr esine. Instantoimme IntStr luokka kahdella esineellä ja suoritti kerrosten jakamisen niiden välillä. Viimeinkin olemme tulostaneet tuloksena olevan arvon käyttäjille.

Nyt kun ymmärrämme onnistuneesti menetelmän mukautetun luokan tekemiseksi kerrosten jakamisen tukemiseksi.

Jos emme pidä siitä, että meidän täytyy soittaa objekti.val nähdäksesi tuloksen, voimme toteuttaa __str__() menetelmä, joka palauttaa arvon suoraan tulostuksen aikana.

Tarkastellaan seuraavaa esimerkkiä, joka osoittaa saman.

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

Lähtö:

 17 // 4 = 4 

Selitys:

Yllä olevassa koodinpätkässä olemme määrittäneet luokan muodossa IntStr joka edustaa kokonaislukuarvot merkkijonoina. Olemme myös toteuttaneet __floordiv__() menetelmä tässä luokassa. Olemme sitten määritelleet __str__() menetelmä, joka palauttaa merkkijonoarvot suoraan tulostuksen aikana. Instantoimme IntStr luokka kahdella esineellä ja suoritti kerrosten jakamisen niiden välillä. Viimeinkin olemme tulostaneet tuloksena olevan arvon käyttäjille.