Come eseguire la divisione del pavimento in Python

In questo tutorial imparerai come eseguire la divisione del pavimento in Python. Utilizzerai l'operatore // di Python, la funzione floor del modulo matematico di Python e altro ancora, con esempi di codice.

Inizieremo con una panoramica degli operatori aritmetici in Python e impareremo come funziona l'operatore di divisione del piano //. Quindi, impareremo come utilizzare altri metodi equivalenti, comprese le funzioni dei moduli matematici e operatore per eseguire la divisione del piano.

Iniziamo…

Operatori aritmetici in Python

In Python, puoi usare gli operatori aritmetici per eseguire semplici operazioni aritmetiche sui numeri dei tipi di dati int e float . Questi operatori agiscono sugli operandi (i numeri) e restituiscono il risultato dell'operazione.

La tabella seguente riassume gli operatori aritmetici in Python e come funzionano:

Prendiamo alcuni esempi che utilizzano questi operatori aritmetici. Puoi provare questi esempi in Python REPL o nell'editor Python online di Geekflare.

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

In questo esempio, num1 è 18 e num2 è 5. L'operazione di divisione num1/num2 restituisce il risultato inclusa la parte frazionaria.

Il numero 5 va in 18 tre volte lasciando un resto di tre. Pertanto, l'operazione di divisione del piano, num1//num2 , fornisce il quoziente 3, mentre l'operatore modulo fornisce il resto – anche 3 in questo caso.

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

Questo dovrebbe darti un'idea di come funzionano gli operatori di divisione, divisione di piano e modulo. Successivamente, conosceremo in dettaglio l'operatore di divisione del piano.

️ In Python 2, l'operazione di divisione (/) tronca il risultato all'intero più vicino, in modo simile all'operazione di divisione del piano in Python 3. Questo tutorial illustra come funziona l'operazione di divisione del piano in Python 3.x.

Divisione Piano Utilizzando l'operatore //

Si consideri un'operazione di divisione con un dividendo e un divisore. In num1/num2 , num1 è il dividendo e num2 è il divisore. Per eseguire la divisione del piano di num1 e num2 , utilizzare num1//num2 .

L' operatore di divisione del piano (//) restituisce il quoziente dell'operazione di divisione, come numero intero o in virgola mobile, a seconda dei tipi di dati degli operandi.

L'operatore di divisione del piano non garantisce che la risposta sia sempre un numero intero. Se il dividendo ( num1 ) o il divisore ( num2 ) è un float, il risultato di num1//num2 è un float. Ecco alcuni esempi.

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

Se è necessario che il risultato sia un numero intero, è necessario eseguirne il cast in modo esplicito in un numero intero usando la funzione int() :

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

Cosa succede sotto il cofano?

Quando si utilizza l'operatore di divisione del piano //, viene chiamato il metodo speciale (chiamato anche metodo dunder) __floordiv__() . Pertanto, puoi anche utilizzare il __floordiv__() su qualsiasi numero intero o in virgola mobile, come mostrato di seguito:

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

Divisione piano Utilizzando operator.floordiv()

Per eseguire la divisione dei piani in Python, puoi anche utilizzare la funzione floordiv() nel modulo operator .

Il modulo operatore di Python contiene le definizioni di funzioni efficienti che possono eseguire tutte le operazioni aritmetiche. Pertanto, per eseguire la divisione del piano, puoi anche utilizzare la funzione floordiv() dal modulo operatore, invece dell'operatore //.

L'uso della funzione floordiv() dal modulo operatore equivale a utilizzare l'operatore di divisione del piano.

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

Divisione piano utilizzando math.floor()

Come funziona la funzione pavimento?

In matematica, la funzione floor() accetta qualsiasi numero reale x come input e restituisce un intero (risultato). Questo risultato è l' intero più grande minore o uguale al numero reale x.

Per capirlo meglio, prendiamo alcuni esempi e visualizziamo questi numeri su una linea numerica.

Esempio 1 : Considera il numero 2.3. Il numero intero più grande minore o uguale a 2,3 è 2; quindi floor(2.3) restituirà 2.

Esempio 2: puoi applicare la stessa definizione anche quando lavori con numeri negativi. Considera il numero -1.7. Il numero intero più grande minore o uguale a -1,7 è -2; quindi floor(-1.7) restituirà -2.

Verifichiamo i risultati precedenti usando la funzione floor() del modulo matematico.

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

Per eseguire la divisione del piano, puoi chiamare la funzione floor() con num1/num2 come argomento. Poiché tronca o arrotonda il risultato al numero intero più vicino, è equivalente all'operazione di divisione del piano.

Puoi importare esplicitamente la funzione floor() dal modulo math , come mostrato:

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

In alternativa, puoi anche importare solo il modulo math e quindi accedere alla funzione floor() usando math.floor() .

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

A differenza della funzione floordiv() del modulo operatore e dell'operatore di divisione del piano //, l'utilizzo math.floor(num1/num2) assicura che il risultato sia un numero intero. Questo metodo rende il codice leggibile ed elimina il passaggio di cast del tipo.

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

Esempi di divisione del pavimento in Python

Concludiamo la nostra discussione con un esempio pratico: ricerca binaria.

La ricerca binaria è un algoritmo di ricerca efficiente che consente di cercare un elemento target attraverso array ordinati in tempo O(log n) , dove n è la dimensione dell'array.

Questo algoritmo funziona dividendo l'intervallo di ricerca a metà ad ogni passaggio. Questo viene fatto a seconda che il punto medio dell'intervallo corrisponda al target (la ricerca termina quando viene trovata una corrispondenza!) o sia minore o maggiore del target. Poiché la dimensione dell'array viene ridotta della metà a ogni passaggio, il punto medio non sempre restituisce un numero intero.

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

Considera la seguente implementazione dell'algoritmo di ricerca binaria. La funzione binary_search() accetta un numero ( item ) e un elenco ( itemlist ) e ricerca l'occorrenza item in itemlist .

• Se l' item viene trovato, la funzione restituisce l'indice a cui si trova l' item .
• Altrimenti, restituisce 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

Questa implementazione è funzionalmente corretta tranne per il fatto che non abbiamo tenuto conto del fatto che midPt non valuta un numero intero mentre la ricerca procede.

 binary_search(item,itemlist)

Se chiamiamo la funzione, ci imbattiamo in un TypeError che afferma che gli indici dell'elenco devono essere interi o sezioni, non 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

Modifichiamo la definizione della funzione per utilizzare l'operatore di divisione del piano:

 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

La funzione restituisce l'indice a cui si trova l'elemento 7, che è l'indice uno.

 binary_search(item,itemlist) # Output: 1

Conclusione

Spero che questo tutorial ti abbia aiutato a capire come eseguire la divisione del pavimento in Python. Ecco un riepilogo dei diversi metodi che hai imparato:

• In Python, un operatore b esegue l'operazione definita dall'operatore con aeb come operandi e restituisce il risultato dell'operazione.
• Puoi usare l'operatore di divisione del piano di Python //; a//b restituisce il quoziente dell'operazione di divisione a/b.
• In alternativa, puoi usare la funzione equivalente floordiv() definita nel modulo operatore di Python con la sintassi: operator.floordiv(a,b) per ottenere il risultato di a//b.
• Tutti i metodi precedenti restituiscono il quoziente ma il tipo di dati può essere float o int a seconda dei valori di a e b. Quindi dovrai eseguire il cast del valore restituito su un numero intero.
• La funzione floor() del modulo matematico di Python può essere utilizzata anche per eseguire la divisione del piano: math.floor(a,b) è equivalente a a//b e restituisce un numero intero. Quando vuoi che il risultato sia un numero intero, considera l'utilizzo della funzione floor dal modulo matematico.

Quindi, scopri come lavorare con defaultdict in Python.