Como executar a divisão de piso em Python

Neste tutorial, você aprenderá como realizar a divisão de piso em Python. Você usará o operador // do Python, a função floor do módulo math do Python e muito mais – com exemplos de código.

Começaremos com uma visão geral dos operadores aritméticos em Python e aprenderemos como o operador de divisão de piso // funciona. Em seguida, aprenderemos como usar outros métodos equivalentes, incluindo funções dos módulos de matemática e operador, para realizar a divisão do piso.

Vamos começar…

Operadores aritméticos em Python

Em Python, você pode usar operadores aritméticos para realizar operações aritméticas simples em números dos tipos de dados int e float . Esses operadores atuam nos operandos (os números) e retornam o resultado da operação.

A tabela a seguir resume os operadores aritméticos em Python e como eles funcionam:

Vejamos alguns exemplos que usam esses operadores aritméticos. Você pode experimentar esses exemplos em um Python REPL ou no editor Python online da Geekflare.

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

Neste exemplo, num1 é 18 e num2 é 5. A operação de divisão num1/num2 retorna o resultado incluindo a parte fracionária.

O número 5 vai para 18 três vezes deixando um resto de três. Portanto, a operação de divisão do piso, num1//num2 , fornece o quociente 3, enquanto o operador módulo fornece o resto – também 3 neste caso.

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

Isso deve dar uma ideia de como os operadores de divisão, divisão de piso e módulo funcionam. A seguir, aprenderemos detalhadamente sobre o operador de divisão de piso.

️ No Python 2, a operação de divisão (/) trunca o resultado para o número inteiro mais próximo, semelhante à operação de divisão de piso no Python 3. Este tutorial discute como a operação de divisão de piso funciona no Python 3.x.

Divisão do andar usando o operador //

Considere uma operação de divisão com um dividendo e um divisor. Em num1/num2 , num1 é o dividendo e num2 é o divisor. Para executar a divisão do piso de num1 e num2 , use num1//num2 .

O operador de divisão de piso (//) retorna o quociente da operação de divisão – como um número inteiro ou de ponto flutuante – dependendo dos tipos de dados dos operandos.

O operador de divisão de piso não garante que a resposta seja sempre um número inteiro. Se o dividendo ( num1 ) ou o divisor ( num2 ) for um float, o resultado de num1//num2 será um float. Aqui estão alguns exemplos.

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

Se você precisa que o resultado seja um inteiro, então você precisa convertê-lo explicitamente em um inteiro usando a função int() :

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

O que acontece sob o capô?

Quando você usa o operador de divisão de piso //, o método especial (também chamado de método dunder) __floordiv__() é chamado. Portanto, você também pode usar o __floordiv__() em qualquer número inteiro ou de ponto flutuante, conforme mostrado abaixo:

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

Divisão do andar Usando o operador.floordiv()

Para realizar a divisão de piso em Python, você também pode usar a função floordiv() no módulo do operator .

O módulo operador do Python contém as definições de funções eficientes que podem realizar todas as operações aritméticas. Portanto, para realizar a divisão do piso, você também pode usar a função floordiv() do módulo do operador – em vez do operador //.

Usar a função floordiv() do módulo operador é equivalente a usar o operador de divisão de piso.

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

Divisão de Piso Usando math.floor()

Como funciona a função de piso?

Em matemática, a função floor() recebe qualquer número real x como entrada e retorna um inteiro (resultado). Este resultado é o maior inteiro que é menor ou igual ao número real x.

Para entender melhor, vamos pegar alguns exemplos e visualizar esses números em uma reta numérica.

Exemplo 1 : Considere o número 2.3. O maior inteiro menor ou igual a 2,3 é 2; então floor(2.3) retornará 2.

Exemplo 2: Você também pode aplicar a mesma definição ao trabalhar com números negativos. Considere o número -1,7. O maior inteiro menor ou igual a -1,7 é -2; então floor(-1.7) retornará -2.

Vamos verificar os resultados acima usando a função floor() do módulo math.

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

Para executar a divisão do piso, você pode chamar a função floor() com num1/num2 como argumento. À medida que trunca ou arredonda o resultado para o número inteiro mais próximo, é equivalente à operação de divisão do piso.

Você pode importar explicitamente a função floor() do módulo math , conforme mostrado:

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

Alternativamente, você também pode importar apenas o módulo math e então acessar a função floor() usando math.floor() .

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

Ao contrário da função floordiv() do módulo operador e do operador de divisão de piso //, usar math.floor(num1/num2) garante que o resultado seja um inteiro. Esse método torna o código legível e elimina a etapa de conversão de tipo.

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

Exemplos de divisão de piso em Python

Vamos concluir nossa discussão com um exemplo prático: Busca binária.

A pesquisa binária é um algoritmo de pesquisa eficiente que permite pesquisar um elemento de destino por meio de matrizes classificadas em tempo O(log n) , onde n é o tamanho da matriz.

Este algoritmo funciona dividindo o intervalo de busca pela metade a cada passo. Isso é feito dependendo se o ponto médio do intervalo corresponde ao destino (a pesquisa termina quando a correspondência é encontrada!) ou é menor ou maior que o destino. Como o tamanho da matriz é reduzido pela metade em cada etapa, o ponto médio nem sempre é avaliado como um número inteiro.

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

Considere a seguinte implementação do algoritmo de busca binária. A função binary_search() recebe um número ( item ) e uma lista ( itemlist ) e procura a ocorrência do item em itemlist .

• Se o item for encontrado, a função retornará o índice no qual o item ocorre.
• Caso contrário, ele retorna 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

Essa implementação está funcionalmente correta, exceto que não consideramos o midPt não sendo avaliado como um inteiro à medida que a pesquisa prossegue.

 binary_search(item,itemlist)

Se chamarmos a função, encontraremos um TypeError informando que os índices da lista devem ser inteiros ou fatias, não flutuantes.

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

Modificamos a definição da função para usar o operador de divisão de piso:

 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

A função retorna o índice no qual o item 7 é encontrado, que é o índice um.

 binary_search(item,itemlist) # Output: 1

Conclusão

Espero que este tutorial tenha ajudado você a entender como realizar a divisão de piso em Python. Aqui está um resumo dos diferentes métodos que você aprendeu:

• Em Python, um operador b executa a operação definida pelo operador com a e b como operandos e retorna o resultado da operação.
• Você pode usar o operador de divisão de piso do Python //; a//b retorna o quociente da operação de divisão a/b.
• Alternativamente, você pode usar a função floordiv() equivalente definida no módulo operador do Python com a sintaxe: operator.floordiv(a,b) para obter o resultado de a//b.
• Todos os métodos acima retornam o quociente, mas o tipo de dados pode ser um float ou um int dependendo dos valores de a e b. Então você terá que converter o valor de retorno para um inteiro.
• A função floor() do módulo math do Python também pode ser usada para realizar a divisão de piso: math.floor(a,b) é equivalente a a//b e retorna um inteiro. Quando você quiser que o resultado seja um número inteiro, considere usar a função floor do módulo math.

Em seguida, aprenda a trabalhar com defaultdict em Python.