Cum se efectuează diviziunea etajului în Python

În acest tutorial, veți învăța cum să efectuați împărțirea podelei în Python. Veți folosi operatorul // al lui Python, funcția de sol din modulul de matematică al lui Python și multe altele - cu exemple de cod.

Vom începe cu o prezentare generală a operatorilor aritmetici din Python și vom afla cum funcționează operatorul de diviziune de etaj //. Apoi, vom învăța cum să folosim alte metode echivalente, inclusiv funcții din modulele de matematică și operator pentru a efectua împărțirea etajului.

Să începem…

Operatori aritmetici în Python

În Python, puteți folosi operatori aritmetici pentru a efectua operații aritmetice simple pe numere de tipul de date int și float . Acești operatori acționează asupra operanzilor (numerele) și returnează rezultatul operației.

Următorul tabel rezumă operatorii aritmetici din Python și modul în care funcționează:

Să luăm câteva exemple care folosesc acești operatori aritmetici. Puteți încerca aceste exemple într-un REPL Python sau în editorul online Python al Geekflare.

 >>> num1 = 18 >>> num2 = 5 >>> num1 + num2 23 >>> num1 - num2 13 >>> num1 * num2 90 >>> num1 ** num2 1889568

În acest exemplu, num1 este 18 și num2 este 5. Operația de împărțire num1/num2 returnează rezultatul, inclusiv partea fracțională.

Numărul 5 intră în 18 de trei ori, lăsând un rest de trei. Prin urmare, operația de împărțire a etajului, num1//num2 , dă coeficientul 3, în timp ce operatorul modulo dă restul – tot 3 în acest caz.

 >>> num1/num2 3.6 >>> num1//num2 3 >>> num1 % num2 3

Acest lucru ar trebui să vă ofere o idee despre modul în care funcționează diviziunea, diviziunea de etaj și operatorii modulo. În continuare, vom afla în detaliu despre operatorul diviziunii de etaj.

️ În Python 2, operația de împărțire (/) trunchiază rezultatul la cel mai apropiat număr întreg — similar cu operația de împărțire a etajului din Python 3. Acest tutorial discută cum funcționează operația de împărțire a etajului în Python 3.x.

Diviziune de etaj Utilizând operatorul //

Luați în considerare o operațiune de divizare cu un dividend și un divizor. În num1/num2 , num1 este dividendul și num2 este divizorul. Pentru a efectua împărțirea etajului a num1 și num2 , utilizați num1//num2 .

Operatorul de împărțire a etajului (//) returnează câtul operației de împărțire — ca un număr întreg sau un număr în virgulă mobilă — în funcție de tipurile de date ale operanzilor.

Operatorul de împărțire a etajului nu se asigură că răspunsul este întotdeauna un număr întreg. Dacă dividendul ( num1 ) sau divizorul ( num2 ) este un float, atunci rezultatul lui num1//num2 este un float. Iată câteva exemple.

 >>> 18.0//5 3.0 >>> 10.0//4 2.0 >>> 15//4.0 3.0

Dacă aveți nevoie ca rezultatul să fie un număr întreg, atunci trebuie să îl transformați în mod explicit într-un număr întreg folosind funcția int() :

 >>> int(18.0//5) 3 >>> int(10.0//4) 2 >>> int(15//4.0) 3

Ce se întâmplă sub capotă?

Când utilizați operatorul de împărțire a etajului //, este apelată metoda specială (numită și metoda dunder) __floordiv__() . Prin urmare, puteți utiliza și metoda __floordiv__() pe orice număr întreg sau cu virgulă mobilă, după cum se arată mai jos:

 num1 = 18 num2 = 5 num1.__floordiv__(num2) # Output: 3

Diviziune de etaj Folosind operator.floordiv()

Pentru a efectua împărțirea etajului în Python, puteți utiliza și funcția floordiv() din modulul operator .

Modulul operator Python conține definițiile funcțiilor eficiente care pot efectua toate operațiile aritmetice. Prin urmare, pentru a efectua împărțirea etajului, puteți utiliza și funcția floordiv() din modulul operator – în loc de operatorul //.

Utilizarea funcției floordiv() din modulul operator este echivalentă cu utilizarea operatorului de împărțire a solului.

 >>> import operator >>> operator.floordiv(18,5) # Output: 3 >>> operator.floordiv(12,5.0) # Output: 2.0

Divizarea etajului folosind math.floor()

Cum funcționează funcția de podea?

În matematică, funcția floor() ia orice număr real x ca intrare și returnează un număr întreg (rezultat). Acest rezultat este cel mai mare număr întreg care este mai mic sau egal cu numărul real x.

Pentru a înțelege mai bine acest lucru, să luăm câteva exemple și să vizualizăm aceste numere pe o linie numerică.

Exemplul 1 : Luați în considerare numărul 2.3. Cel mai mare număr întreg care este mai mic sau egal cu 2,3 ​​este 2; deci floor(2.3) va returna 2.

Exemplul 2: Puteți aplica aceeași definiție și atunci când lucrați cu numere negative. Luați în considerare numărul -1,7. Cel mai mare număr întreg care este mai mic sau egal cu -1,7 este -2; deci floor(-1,7) va returna -2.

Să verificăm rezultatele de mai sus folosind funcția floor() din modulul de matematică.

 >>> from math import floor >>> floor(2.3) 2 >>> floor(-1.7) -2

Pentru a efectua împărțirea etajului, puteți apela funcția floor() cu num1/num2 ca argument. Pe măsură ce trunchiază sau rotunjește în jos rezultatul la cel mai apropiat număr întreg, este echivalent cu operația de împărțire a etajului.

Puteți importa în mod explicit funcția floor() din modulul de math , după cum se arată:

 from math import floor num1 = 18 num2 = 5 floor(num1/num2) # Output: 3

Alternativ, puteți importa doar modulul math și apoi accesați funcția floor() folosind math.floor() .

 import math num1 = 18 num2 = 5 math.floor(num1/num2) # Output: 3

Spre deosebire de funcția floordiv() din modulul operator și operatorul de diviziune de etaj //, utilizarea math.floor(num1/num2) asigură că rezultatul este un întreg. Această metodă face codul lizibil și elimină etapa de turnare a tipului.

 import math num1 = 18.0 num2 = 5 math.floor(num1/num2) # Output: 3

Exemple de diviziune a podelei în Python

Să încheiem discuția noastră cu un exemplu practic: Căutare binară.

Căutarea binară este un algoritm de căutare eficient care vă permite să căutați un element țintă prin matrice sortate în timp O(log n) , unde n este dimensiunea matricei.

Acest algoritm funcționează prin împărțirea intervalului de căutare la jumătate la fiecare pas. Acest lucru se face în funcție de faptul dacă punctul de mijloc al intervalului se potrivește cu ținta (căutarea se termină pe măsură ce se găsește potrivirea!) sau este mai mic sau mai mare decât țintă. Deoarece dimensiunea matricei este redusă la jumătate la fiecare pas, punctul de mijloc nu este întotdeauna evaluat la un număr întreg.

 itemlist = [5,7,18,21,34,45] item = 7

Luați în considerare următoarea implementare a algoritmului de căutare binar. Funcția binary_search() preia un număr ( item ) și o listă ( itemlist ) și caută apariția item în itemlist .

• Dacă item este găsit, funcția returnează indexul la care apare item .
• În caz contrar, returnează None .

 def binary_search(item, itemlist): # get the list size listsize = len(itemlist) - 1 # start at the two ends of the list lowerIdx = 0 upperIdx = listsize while lowerIdx <= upperIdx: # calculate the middle point # use normal division instead of floor division midPt = (lowerIdx + upperIdx)/ 2 # if item is found, return the index if itemlist[midPt] == item: return midPt # otherwise get the next midpoint if item > itemlist[midPt]: lowerIdx = midPt + 1 else: upperIdx = midPt - 1 if lowerIdx > upperIdx: return None

Această implementare este corectă din punct de vedere funcțional, cu excepția faptului că nu am luat în considerare faptul că midPt nu se evaluează la un număr întreg pe măsură ce căutarea continuă.

 binary_search(item,itemlist)

Dacă apelăm funcția, întâlnim o TypeError care afirmă că indicii listei trebuie să fie numere întregi sau felii, nu float.

 --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-3-a5f12ebc3145> in <module> ----> 1 binary_search(item,itemlist) <ipython-input-2-524ef6900b1f> in binary_search(item, itemlist) 12 13 # if item is found, return the index ---> 14 if itemlist[midPt] == item: 15 return midPt 16 # otherwise get the next midpoint TypeError: list indices must be integers or slices, not float

Modificăm definiția funcției pentru a folosi operatorul de împărțire a etajului:

 def binary_search(item, itemlist): # get the list size listsize = len(itemlist) - 1 # start at the two ends of the list lowerIdx = 0 upperIdx = listsize while lowerIdx <= upperIdx: # calculate the middle point # use floor division midPt = (lowerIdx + upperIdx)// 2 # if item is found, return the index if itemlist[midPt] == item: return midPt # otherwise get the next midpoint if item > itemlist[midPt]: lowerIdx = midPt + 1 else: upperIdx = midPt - 1 if lowerIdx > upperIdx: return None

Funcția returnează indexul la care se găsește elementul 7, care este indicele unu.

 binary_search(item,itemlist) # Output: 1

Concluzie

Sper că acest tutorial v-a ajutat să înțelegeți cum să efectuați împărțirea podelei în Python. Iată un rezumat al diferitelor metode pe care le-ați învățat:

• În Python, un operator b realizează operația definită de operator cu a și b ca operanzi și returnează rezultatul operației.
• Puteți folosi operatorul Python de împărțire a podelei //; a//b returnează câtul operației de împărțire a/b.
• Alternativ, puteți utiliza funcția echivalentă floordiv() definită în modulul operator Python cu sintaxa: operator.floordiv(a,b) pentru a obține rezultatul a//b.
• Toate metodele de mai sus returnează coeficientul, dar tipul de date poate fi un float sau un int, în funcție de valorile lui a și b. Deci, va trebui să turnați valoarea returnată la un număr întreg.
• Funcția floor() din modulul matematic al lui Python poate fi folosită și pentru a efectua împărțirea etajului: math.floor(a,b) este echivalent cu a//b și returnează un număr întreg. Când doriți ca rezultatul să fie un întreg, luați în considerare utilizarea funcției floor din modulul de matematică.

Apoi, aflați cum să lucrați cu defaultdict în Python.