No tutorial a seguir, aprenderemos sobre a operação Floor Division usando a linguagem de programação Python.
Mas antes de começarmos, vamos entender brevemente o que é divisão de piso.
Compreendendo a divisão do andar
A divisão de piso é uma operação de divisão normal, exceto que retorna o maior número inteiro possível. Este número inteiro pode ser menor que a saída da divisão normal ou igual a ela.
A função floor é representada pelo símbolo ⌊ ⌋ em termos matemáticos.
Vamos agora entender o funcionamento da operação de divisão de pisos. Por exemplo,
⌊36/5⌋
Passo 1: Realizando a divisão primeiro. Nós vamos dividir 36 por 5 .
36÷5 = 7,2
Passo 2: Agora, executaremos a função floor no valor que obtemos após a divisão, ou seja, 7.2 .
⌊7,2⌋=7
Como resultado, obtemos 7 qual é o valor mínimo de 7.2 . Portanto, divisão mínima significa dividir e arredondar para o número inteiro mais próximo.
Diferentes linguagens de programação oferecem uma função ou operador integrado específico para calcular a divisão do piso. Alguns exemplos podem ser:
- Podemos usar o chão() método na linguagem de programação C++.
- Podemos usar o chão() método na linguagem de programação Java.
- Podemos usar o // operador na linguagem de programação Python.
No entanto, discutiremos apenas o uso da operação de divisão de piso em Python com a ajuda do operador de barra invertida dupla (//) .
como criar um array em java
Compreendendo a divisão de piso usando Python
Na linguagem de programação Python, a divisão mínima é usada para dividir dois números e arredondar o resultado para o número inteiro mais próximo.
Antes de nos aprofundarmos no conceito de divisão de pisos, lembremo-nos brevemente do significado da divisão e do funcionamento do matemática.floor() função em Python.
Executando Divisão Regular em Python
Podemos dividir dois números usando a barra invertida ( / ) operador de divisão em Python. Consideremos o seguinte exemplo que demonstra o mesmo:
Exemplo 1:
# declaring variables a = 13 b = 4 # performing regular division c = a / b # printing the result print(a, '/', b, '=', c)
Saída:
13 / 4 = 3.25
Explicação:
No trecho de código acima, definimos duas variáveis como uma = 13 e b = 4 . Em seguida, realizamos uma operação de divisão usando a barra invertida ( / ) operador de divisão e armazenou o valor resultante em uma nova variável, c . Por fim, imprimimos o valor de c .
Como podemos ver, a divisão em Python funciona da mesma forma que a divisão em matemática.
Compreendendo a função math.floor() em Python
Existe um módulo matemático integrado no Python que consiste em diferentes utilitários matemáticos úteis para cálculos.
Uma dessas funções integradas do matemática módulo é o matemática.floor() função. Esta função aceita uma entrada numérica e retorna o valor mínimo arredondando-o para o número inteiro mais próximo.
Consideremos o seguinte exemplo demonstrando o mesmo:
Exemplo 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)
Saída:
Floor value of 5.34 = 5 Floor value of -5.34 = 6
Explicação:
No trecho de código acima, importamos o chão() função do matemática módulo. Declaramos então duas variáveis como uma = 5,34 e b = -5,34 . Usamos então o chão() função para calcular os valores mínimos de ambas as variáveis e armazená-los em novas variáveis, c e d . Por fim, imprimimos os resultados para os usuários.
Agora que entendemos os conceitos de divisão e piso de números em Python. Vamos aos detalhes associados à divisão de piso em Python.
Executando divisão de piso em Python
A divisão de piso é uma operação em Python que nos permite dividir dois números e arredondar o valor resultante para o número inteiro mais próximo. A divisão do piso ocorre através do operador de barra invertida dupla (//) . A sintaxe do mesmo é mostrada abaixo:
Sintaxe:
res = var_1 // var_2
Onde:
Podemos pensar na divisão de pisos como a divisão regular combinada com o matemática.floor() chamada de função.
Nota: A divisão de piso pode arredondar qualquer número para o número inteiro mais próximo. Por exemplo, 3,99 ainda será arredondado para 3.
Consideremos agora um exemplo que demonstra o funcionamento da divisão de pisos.
Exemplo 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)
Saída:
Floor Division: 13 // 5 = 2 Regular Division: 13 / 5 = 2.6
Explicação:
No trecho de código acima, declaramos duas variáveis como uma = 13 e b = 5 . Usamos então o // operador para calcular o valor da divisão do piso e armazenou o valor do piso em uma nova variável, c . Em seguida, realizamos a divisão regular usando o / operador e armazenou o valor em outra variável, d . Por fim, imprimimos os resultados e os comparamos.
Agora, vamos considerar outro exemplo usando o matemática.floor() função.
Exemplo 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)
Saída:
Floor Division using floor() function: 3 Floor Division using // operator: 3
Explicação:
Nós importamos o chão() função do matemática módulo no trecho de código acima. Declaramos então duas variáveis como uma = 17 e b = 5 . Usamos então o chão() função, dividida a por b e armazenou-o na variável c. Calculamos então o valor mínimo usando o // operador e armazenou o valor em uma nova variável, d . Por fim, imprimimos os dois valores e os comparamos.
Realizando Divisão de Andar com Números Negativos
Também podemos realizar a divisão de pisos usando números negativos.
No caso de números negativos, o valor resultante ainda é arredondado para o número inteiro mais próximo. Alguns podem ficar confusos porque arredondar para baixo um número negativo implica sair do zero. Por exemplo, -23 é piso até -3 .
Consideremos um exemplo que demonstra a divisão de pisos com números negativos.
Exemplo 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)
Saída:
Floor Division: -10 // 4 = -3
Explicação:
No trecho de código acima, declaramos duas variáveis como uma = -10 e b = 4 . Usamos então o // operador para calcular o valor mínimo e armazená-lo em uma nova variável, c . Por fim, imprimimos o valor para o usuário.
Com uma divisão regular, -10/4 retornaria -2,5 ; entretanto, com uma divisão por piso, esse número é arredondado para o número inteiro negativo mais próximo, ou seja, para -3 .
Realizando Divisão de Piso com Flutuadores
Também podemos realizar a divisão Floor com floats em Python. Quando a divisão de piso flutua, o resultado é um flutuador que representa o número inteiro mais próximo.
Consideremos o seguinte exemplo demonstrando a divisão do piso usando flutuadores.
Exemplo 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)
Saída:
17.5 // 3.3 = 5.0 10 // 2.5 = 4.0 13.4 // 3 = 4.0
Explicação:
No trecho de código acima, inicializamos duas listas. Usamos então o para -loop para iterar pelos elementos dessas listas, calcular os valores de cada operação de divisão de pisos e imprimir os resultados para os usuários.
Como resultado, podemos observar que a operação de divisão de piso é realizada usando floats e float com inteiro retorna o valor arredondado para o inteiro mais próximo representado como float.
Divisão de piso e módulo em Python
Em Matemática, módulo é um conceito associado principalmente à divisão de pisos. Também podemos dizer que módulo significa o resto da divisão entre dois números. Em outras palavras, podemos contar o número de sobras com ele.
Podemos calcular o módulo em Python usando a porcentagem ( % ) operador.
Vamos considerar um exemplo que ilustra a relação entre a divisão do piso e o módulo em Python.
Exemplo 7.1:
Dados 13 doces e 4 comedores, podemos calcular a quantidade de doces que cada comedor recebe com a ajuda da divisão por piso.
Código:
# 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)
Saída:
Number of Candies: 13 Number of Eaters: 4 The number of candies each eater gets: 3
Explicação:
No trecho de código acima, declaramos algumas variáveis que significam o número de doces e comedores. Usamos então o // operador para realizar a divisão do andar para calcular a quantidade de doces que cada comedor recebe. Em seguida, imprimimos esses valores para o usuário.
Vamos agora calcular o número total de doces compartilhados entre o grupo. Isto não é muito importante.
Exemplo 7.2:
Multiplicaremos o número de doces por pessoa pelo número de comedores.
Código:
# 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)
Saída:
The total number of candies being shared among the group: 12
Explicação:
No trecho de código acima, calculamos o número total de doces compartilhados entre o grupo multiplicando o número de doces por pessoa pelo número de comedores e imprimimos o valor resultante para os usuários.
O número total de doces completos compartilhados é 12 . No entanto, o número total de doces é 13 . Esta afirmação implica que sobrará um doce e não será comido.
O exemplo acima descreve uma maneira de calcular o número de sobras. Porém, se estivermos interessados apenas na quantidade de sobras, podemos calculá-la diretamente com a ajuda do módulo.
css para negrito
Exemplo 7.3:
Dados 13 doces e 4 comedores, qual é o número de doces que sobraram?
Código:
# 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)
Saída:
Number of Candies: 13 Number of Eaters: 4 Total number of Leftover Candies: 1
Explicação:
opa
No trecho de código acima, declaramos as variáveis que armazenam o valor doces e comedores. Calculamos então o número de doces que sobraram usando o % operador que significa a operação do módulo. Por fim, imprimimos algumas declarações e valores resultantes para os usuários. Como resultado, podemos ver que o doce que sobrou é 1 .
a = b * (a // b) + (a% b)
Em Python, a divisão do piso e o módulo estão relacionados pela seguinte equação:
Onde:
Por exemplo, vamos verificar se a equação acima se aplica aos 13 doces e aos 4 comedores.
13 = 4 * (13 // 4) + (13% 4)
13 = 4 * 3 + 1
13 = 13
Assim, entendemos os conceitos de divisão de piso e módulo em Python. Agora, veremos algumas funções integradas que calculam ambos.
Compreendendo a função divmod() em Python
Python oferece uma função integrada chamada divmod() isso nos permite calcular a divisão do piso e o módulo entre dois valores numéricos.
A sintaxe para o divmod() função é mostrada abaixo:
Sintaxe:
res = divmod(var_1, var_2)
Onde:
Consideremos agora o seguinte exemplo que demonstra a divmod() função.
Exemplo 8:
Dados 13 doces e 4 comedores, quantos doces cheios cada comedor recebe e quantos doces restam?
Código:
# 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)
Saída:
Number of Candies: 13 Number of Eaters: 4 Number of Candies per eater: 3 Total number of Leftover Candies: 1
Explicação:
No trecho de código acima, declaramos algumas variáveis. Nós usamos o divmod() função para calcular o valor da divisão do piso e o módulo para as variáveis fornecidas. Em seguida, imprimimos esses valores para os usuários.
Compreendendo a precedência da divisão de piso
Em Python, o operador de divisão de piso // tem o nível de precedência semelhante à multiplicação ( * ), divisão ( / ) e módulo ( % ).
Esta afirmação implica que se multiplicarmos e depois dividirmos por piso, a multiplicação é alcançada primeiro, e depois a divisão por piso e vice-versa.
No entanto, se, por exemplo, subtrairmos dois números e depois realizarmos a divisão por piso, a operação de divisão por piso abrirá o caminho.
Vamos considerar um exemplo que demonstra o mesmo.
Exemplo 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)
Saída:
3 * 5 // 6 - 7 = -5
Explicação:
No trecho de código acima, declaramos algumas variáveis como uma = 3, b = 5, c = 6 , e d = 7 . Em seguida, realizamos uma operação e armazenamos o valor resultante em uma nova variável, e . Por fim, imprimimos esse valor para os usuários.
Para entender como esse resultado é calculado, podemos inserir parênteses em torno dos termos na ordem de precedência correta.
O exemplo mostrado abaixo mostra o mesmo:
Exemplo 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)
Saída:
(( 3 * 5 ) // 6 ) - 7 = -5
Explicação:
No trecho de código acima, declaramos algumas variáveis como uma = 3, b = 5, c = 6 , e d = 7 . Em seguida, realizamos a mesma operação, mas com parênteses, e armazenamos o valor resultante em uma nova variável, e . Por fim, imprimimos esse valor para os usuários.
Como podemos observar que obtemos o resultado semelhante ao do exemplo anterior, o que significa que a ordem de cálculo é:
Multiplicação → Divisão de Piso → Subtração
Aqui está o cálculo passo a passo do acima:
3 * 5 // 6 - 7
((3 * 5) // 6) - 7
(15 // 6) - 7
2 - 7
-5
Compreendemos corretamente a divisão de pisos e seu uso na linguagem de programação Python.
Por fim, veremos um caso de uso avançado para divisão de pisos. No caso a seguir, avançado não significa difícil; no entanto, é bastante incomum.
Compreendendo o uso avançado da divisão de piso
Alguns de nós devem estar cientes de que também podemos criar objetos personalizados que suportam a operação de divisão de piso em Python. Isto pode ser possível através de um método especial conhecido como __floordiv__() .
O método __floordiv__() em Python
A operação de divisão mínima em Python é usada para dividir dois números e arredondar o resultado para o número inteiro mais próximo.
Ele funciona nos bastidores porque um tipo numérico implementa um método especial chamado __floordiv__() . Então, sempre que ligarmos para o // operador entre dois objetos, o __floordiv__() o método é chamado.
Em Python, também podemos chamar diretamente o __floordiv__() método. Consideremos o seguinte exemplo demonstrando o mesmo:
Exemplo 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)
Saída:
Using the // operator: 31 // 7 = 4 Using the __floordiv__() method: ( 31 ).__floordiv__( 7 ) = 4
Explicação:
No trecho de código acima, declaramos duas variáveis como uma = 31 e b = 7 . Em seguida, realizamos a divisão do piso usando o // operador e __floordiv__() método e armazenou seus valores resultantes em duas variáveis, c e d . Por fim, imprimimos os resultados para os usuários.
A partir da saída mostrada acima, podemos observar que ambas as expressões produziram o mesmo resultado. Isso ocorre porque a primeira expressão é convertida na segunda expressão. Em outras palavras, essas chamadas são equivalentes entre si.
Agora, as coisas vão ficar interessantes. Consideremos o seguinte exemplo.
Exemplo 11.1:
Criaremos uma classe personalizada representando os valores inteiros como strings no exemplo a seguir. Em seguida, criaremos dois objetos desta classe personalizada e realizaremos a operação de divisão de piso neles.
Código:
# 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)
Saída:
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'
Explicação:
No trecho de código acima, definimos uma classe como IntStr que representa os valores inteiros como strings. Criamos então dois objetos do IntStr aula. Por fim, temos a divisão por piso entoar objeto pelo intDois objeto e tentei imprimir o resultado.
No entanto, a saída acima indica um Erro de tipo . Esta mensagem de erro revela que IntStr objetos não suportam divisão de piso. Este erro faz sentido. Como o tipo personalizado teria alguma pista de objetos de strings que dividem o chão?
No entanto, como se vê, podemos fazer o IntStr divisão de piso de suporte de objetos.
Anteriormente, aprendemos sempre que chamamos o // operador, chamamos o __floordiv__() método. Este método é executado em algum lugar da classe do objeto. Por exemplo, objetos int suportam divisão de piso porque a classe int aplicou o __floordiv__() método.
Esses métodos especiais, como __floordiv__() , temos algo incrível em comum: podemos implementar esses métodos na classe personalizada. Em outras palavras, podemos fazer com que os objetos personalizados suportem a divisão de piso na linguagem de programação Python.
Consideremos agora o seguinte exemplo que demonstra o mesmo.
carneiro potineni
Exemplo 11.2:
No exemplo a seguir, implementaremos o __floordiv__() método para o IntStr aula. Em seguida, criaremos dois objetos desta classe personalizada e realizaremos a operação de divisão de piso neles.
Código:
# 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)
Saída:
17 // 4 = 4
Explicação:
No trecho de código acima, definimos uma classe como IntStr que representa os valores inteiros como strings. Também implementamos o __floordiv__() método dentro desta classe. Este método aceita o valor da string numérica dele mesmo e de outro objeto. Convertemos esses valores de string em números inteiros e realizamos uma divisão mínima entre eles. Em seguida, convertemos o resultado novamente em uma string e criamos um novo IntStr objeto. Nós instanciamos o IntStr classe com dois objetos e realizou uma operação de divisão de piso entre eles. Por fim, imprimimos o valor resultante para os usuários.
Agora que entendemos com sucesso o método de criação de uma classe personalizada para oferecer suporte à divisão de pisos.
Se não gostamos do facto de termos de telefonar objeto.val para ver o resultado, podemos implementar o __str__() método que retorna diretamente o valor durante a impressão.
Vamos considerar o exemplo a seguir demonstrando o mesmo.
Exemplo 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)
Saída:
17 // 4 = 4
Explicação:
No trecho de código acima, definimos uma classe como IntStr que representa os valores inteiros como strings. Também implementamos o __floordiv__() método dentro desta classe. Definimos então o __str__() método que retorna diretamente os valores da string durante a impressão. Nós instanciamos o IntStr classe com dois objetos e realizou uma operação de divisão de piso entre eles. Por fim, imprimimos o valor resultante para os usuários.