В следващия урок ще научим за операцията Floor Division с помощта на езика за програмиране Python.
Но преди да започнем, нека разберем накратко какво е разделяне на етажите.
Разбиране на разделението на пода
Делението на етажа е нормална операция за деление, освен че връща възможно най-голямото цяло число. Това цяло число може да бъде или по-малко от изхода от нормалното деление, или равно на него.
Подовата функция се обозначава със символа ⌊ ⌋ в математически термини.
Нека сега разберем работата на операцията за разделяне на етажа. Например,
⌊36/5⌋
Етап 1: Първо извършване на разделянето. Ще разделим 36 от 5 .
36 ÷ 5 = 7,2
Стъпка 2: Сега ще изпълним подовата функция върху стойността, която получаваме след разделянето, т.е. 7.2 .
⌊7,2⌋=7
В резултат на това получаваме 7 което е долната стойност на 7.2 . Следователно деление на етаж означава деление и закръгляване надолу до най-близкото цяло число.
Различните езици за програмиране предлагат конкретна вградена функция или оператор за изчисляване на разделянето на етажа. Някои примери могат да бъдат:
- Можем да използваме етаж() метод в езика за програмиране C++.
- Можем да използваме етаж() метод в езика за програмиране Java.
- Можем да използваме // оператор в езика за програмиране Python.
Ние обаче ще обсъждаме само използването на операцията за разделяне на етажа в Python с помощта на оператор с двойна обратна наклонена черта (//). .
Разбиране на разделението на етажите с помощта на Python
В езика за програмиране Python делението на пода се използва за разделяне на две числа и закръглява резултата до най-близкото цяло число.
Преди да се потопим по-дълбоко в концепцията за разделяне на етажа, нека накратко да си припомним значението на разделението и работата на math.floor() функция в Python.
Извършване на редовно деление в Python
Можем да разделим две числа, като използваме обратната наклонена черта ( / ) оператор за деление в Python. Нека разгледаме следния пример, демонстриращ същото:
Пример 1:
# declaring variables a = 13 b = 4 # performing regular division c = a / b # printing the result print(a, '/', b, '=', c)
Изход:
13 / 4 = 3.25
Обяснение:
В горния кодов фрагмент сме дефинирали две променливи като а = 13 и b = 4 . След това извършихме операция за разделяне, използвайки обратната наклонена черта ( / ) оператор за деление и съхранява получената стойност в нова променлива, ° С . Най-накрая отпечатахме стойността на ° С .
Както виждаме, делението в Python работи по същия начин, както делението работи в математиката.
Разбиране на функцията math.floor() в Python
В Python има вграден математически модул, който се състои от различни полезни математически помощни програми за изчисления.
Една такава вградена функция на математика модулът е math.floor() функция. Тази функция приема цифров вход и връща стойността на пода, като я закръгля надолу до най-близкото цяло число.
Нека разгледаме следния пример, демонстриращ същото:
Пример 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)
Изход:
Floor value of 5.34 = 5 Floor value of -5.34 = 6
Обяснение:
В горния кодов фрагмент ние импортирахме етаж() функция от математика модул. След това сме декларирали две променливи като а = 5,34 и b = -5,34 . След това използвахме етаж() функция за изчисляване на долните стойности на двете променливи и съхраняването им в нови променливи, ° С и д . Най-накрая отпечатахме резултатите за потребителите.
Сега, след като разбрахме концепциите за разделяне и подови числа в Python. Нека се насочим към подробностите, свързани с разделянето на етажите в Python.
Изпълнение на Floor Division в Python
Етажното деление е операция в Python, която ни позволява да разделим две числа и закръгля получената стойност надолу до най-близкото цяло число. Подовото разделяне става чрез оператор с двойна обратна наклонена черта (//). . Синтаксисът за същото е показан по-долу:
шехзад пунавала
Синтаксис:
res = var_1 // var_2
Където:
urfi javed
Можем да мислим за разделянето на етажите като редовното разделение, комбинирано с math.floor() извикване на функция.
Забележка: Делението на пода може да закръгли всяко число надолу до най-близкото цяло число. Например 3,99 пак ще бъде закръглено надолу до 3.
Нека сега разгледаме пример, демонстриращ работата на подовото разделяне.
Пример 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)
Изход:
Floor Division: 13 // 5 = 2 Regular Division: 13 / 5 = 2.6
Обяснение:
В горния кодов фрагмент сме декларирали две променливи като а = 13 и b = 5 . След това използвахме // оператор за изчисляване на стойността на разделяне на етажа и съхранява стойността на пода в нова променлива, ° С . След това извършихме редовното деление, използвайки / оператор и съхранява стойността в друга променлива, д . Най-накрая отпечатахме и двата резултата и ги сравнихме.
Сега нека разгледаме друг пример, използвайки math.floor() функция.
Пример 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)
Изход:
Floor Division using floor() function: 3 Floor Division using // operator: 3
Обяснение:
Ние сме внесли етаж() функция от математика модул в горния кодов фрагмент. След това сме декларирали две променливи като а = 17 и b = 5 . След това използвахме етаж() функция, разделена а от b и го съхранява в променлива c. След това сме изчислили стойността на пода с помощта на // оператор и съхранява стойността в нова променлива, д . Най-накрая отпечатахме и двете стойности и ги сравнихме.
Извършване на етажно деление с отрицателни числа
Можем също така да извършим етажно деление с помощта на отрицателни числа.
В случай на отрицателни числа, получената стойност все още се закръгля надолу до най-близкото цяло число. Някои може да се объркат, като закръглят надолу отрицателно число, което предполага отдалечаване от нула. Например, -23 е надолу до -3 .
Нека разгледаме пример, демонстриращ разделянето на етажа с отрицателни числа.
Пример 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)
Изход:
Floor Division: -10 // 4 = -3
Обяснение:
В горния кодов фрагмент сме декларирали две променливи като а = -10 и b = 4 . След това използвахме // оператор за изчисляване на долната стойност и я съхранява в нова променлива, ° С . Най-накрая отпечатахме стойността за потребителя.
С редовно разделение, -10/4 би се върнал -2,5 ; обаче, с подово деление, това число се закръгля надолу до най-близкото отрицателно цяло число, т.е. -3 .
Изпълнение на разделяне на етаж с плувки
Можем също така да извършим разделяне на етажи с плаващи елементи в Python. Когато float-разделяне на етажа, резултатът е float, представляващ най-близкото цяло число.
Нека разгледаме следния пример, демонстриращ разделянето на пода с помощта на плувки.
Пример 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)
Изход:
17.5 // 3.3 = 5.0 10 // 2.5 = 4.0 13.4 // 3 = 4.0
Обяснение:
В горния кодов фрагмент сме инициализирали два списъка. След това използвахме за -цикъл за итерация през елементите на тези списъци, изчислява стойностите за всяка операция за разделяне на етажа и отпечатва резултатите за потребителите.
В резултат на това можем да наблюдаваме, че операцията за разделяне на етажа се извършва с помощта на плаващи числа и float с цяло число връща стойността, закръглена надолу до най-близкото цяло число, представено като плаващи числа.
Floor Division и Modulo в Python
В математиката модулът е концепция, свързана главно с разделяне на етажи. Можем също така да кажем, че модуло означава остатъка от делението между две числа. С други думи, можем да преброим броя на остатъците с него.
Можем да изчислим по модул в Python, като използваме процента ( % ) оператор.
Нека разгледаме пример, илюстриращ връзката между разделянето на етажа и модула в Python.
Пример 7.1:
Дадени са 13 бонбона и 4 ядещи, можем да изчислим броя бонбони, които всеки яде получава с помощта на разделянето на пода.
Код:
видове for цикъл
# 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)
Изход:
Number of Candies: 13 Number of Eaters: 4 The number of candies each eater gets: 3
Обяснение:
В горния кодов фрагмент сме декларирали някои променливи, означаващи броя на бонбоните и ядещите. След това използвахме // оператор, който да извърши разделяне на етажите, за да изчисли броя на бонбоните, които получава всеки ядещ. След това отпечатахме тези стойности за потребителя.
Нека сега изчислим общия брой бонбони, споделени между групата. Това не е много важно.
Пример 7.2:
Ще умножим броя на бонбоните на човек по броя на ядещите.
Код:
# 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)
Изход:
The total number of candies being shared among the group: 12
Обяснение:
В горния фрагмент от код изчислихме общия брой бонбони, споделяни между групата, като умножихме броя на бонбоните на човек по броя на ядещите и отпечатахме получената стойност за потребителите.
Общият брой споделени пълни бонбони е 12 . Общият брой на бонбоните обаче е 13 . Това твърдение предполага, че един бонбон ще остане и няма да бъде изяден.
Горният пример описва един начин за изчисляване на броя на остатъците. Ако обаче се интересуваме само от броя на остатъците, можем директно да го изчислим с помощта на модул.
Пример 7.3:
Дадени са 13 бонбона и 4 ядещи, какъв е броят на остатъчните бонбони?
Код:
# 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)
Изход:
Number of Candies: 13 Number of Eaters: 4 Total number of Leftover Candies: 1
Обяснение:
В горния кодов фрагмент сме декларирали променливите, съхраняващи стойността candies и eaters. След това изчислихме броя на остатъчните бонбони, използвайки % оператор, обозначаващ модулната операция. Най-накрая отпечатахме някои твърдения и произтичащи стойности за потребителите. В резултат на това можем да видим, че остатъкът от бонбони е 1 .
a = b * (a // b) + (a % b)
В Python делението на пода и модула са свързани със следното уравнение:
Където:
Например, нека проверим дали горното уравнение е валидно с 13-те бонбона и 4-те ядещи.
13 = 4 * (13 // 4) + (13% 4)
13 = 4 * 3 + 1
13 = 13
По този начин разбрахме концепциите за етажно деление и модул в Python. Сега ще разгледаме някаква вградена функция, която изчислява и двете.
Разбиране на функцията divmod() в Python
Python предлага вградена функция, наречена divmod() което ни позволява да изчислим както делението на пода, така и модула между две числови стойности.
Синтаксисът за divmod() функция е показана по-долу:
Синтаксис:
res = divmod(var_1, var_2)
Където:
Нека сега разгледаме следния пример, демонстриращ divmod() функция.
Пример 8:
Дадени са 13 бонбона и 4 ядене, колко пълни бонбони получава всеки ядец и колко бонбона остават?
Код:
# 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)
Изход:
Number of Candies: 13 Number of Eaters: 4 Number of Candies per eater: 3 Total number of Leftover Candies: 1
Обяснение:
В горния фрагмент от код сме декларирали някои променливи. Ние сме използвали divmod() функция за изчисляване на стойността на делението на пода и модула за дадените променливи. След това отпечатахме тези стойности за потребителите.
уебсайт като coomeet
Разбиране на приоритета на подразделението
В Python, операторът за разделяне на етажа // има подобно ниво на приоритет като умножението ( * ), разделение ( / ), и по модул ( % ).
Това твърдение предполага, че ако умножаваме и след това делим на етаж, първо се постига умножението, а след това делението на етаж и обратно.
Въпреки това, ако например извадим две числа и след това извършим деление на етаж, операцията за деление на етаж ще проправи пътя.
Нека разгледаме пример, демонстриращ същото.
Пример 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)
Изход:
3 * 5 // 6 - 7 = -5
Обяснение:
В горния кодов фрагмент сме декларирали някои променливи като a = 3, b = 5, c = 6 , и d = 7 . След това извършихме операция и съхранихме получената стойност в нова променлива, то е . Най-накрая отпечатахме тази стойност за потребителите.
За да разберем как се изчислява този резултат, можем да поставим скоби около термините в правилния ред на приоритет.
Примерът, показан по-долу, показва същото:
Пример 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)
Изход:
(( 3 * 5 ) // 6 ) - 7 = -5
Обяснение:
В горния кодов фрагмент сме декларирали някои променливи като a = 3, b = 5, c = 6 , и d = 7 . След това извършихме същата операция, но със скоби и съхранихме получената стойност в нова променлива, то е . Най-накрая отпечатахме тази стойност за потребителите.
Както можем да забележим, че получаваме подобен резултат като от предишния пример, което означава, че редът на изчисление е:
Умножение → Етажно деление → Изваждане
Ето поетапното изчисление на горното:
3 * 5 // 6 - 7
((3 * 5) // 6) - 7
(15 // 6) - 7
2 - 7
-5
Ние разбрахме правилно разделянето на етажа и неговото използване в езика за програмиране Python.
Най-накрая ще разгледаме един усъвършенстван случай на използване за разделянето на етажа. В следния случай напреднал не означава труден; обаче е доста необичайно.
Разбиране на предварителното използване на етажното разделение
Някои от нас може би са наясно, че можем също така да създаваме потребителски обекти, поддържащи операцията за разделяне на етажа в Python. Това може да стане чрез специален метод, известен като __floordiv__() .
Методът __floordiv__() в Python
Операцията за деление на пода в Python се използва за разделяне на две числа и закръглява резултата надолу до най-близкото цяло число.
Работи под капака, защото числовият тип имплементира специален метод, наречен __floordiv__() . След това, когато се обадим на // оператор между два обекта, the __floordiv__() методът се извиква.
В Python можем също директно да извикаме __floordiv__() метод. Нека разгледаме следния пример, демонстриращ същото:
Пример 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)
Изход:
Using the // operator: 31 // 7 = 4 Using the __floordiv__() method: ( 31 ).__floordiv__( 7 ) = 4
Обяснение:
как да сортирате arraylist в java
В горния кодов фрагмент сме декларирали две променливи като а = 31 и b = 7 . След това извършихме разделяне на етажа с помощта на // оператор и __floordiv__() метод и съхранява техните резултантни стойности в две променливи, ° С и д . Най-накрая отпечатахме резултатите за потребителите.
От изхода, показан по-горе, можем да видим, че и двата израза са дали един и същ резултат. Това е така, защото първият израз се преобразува във втория израз. С други думи, тези обаждания са еквивалентни едно на друго.
Сега нещата ще станат интересни. Нека разгледаме следния пример.
Пример 11.1:
Ще създадем персонализиран клас, представящ целочислените стойности като низове в следващия пример. След това ще създадем два обекта от този потребителски клас и ще извършим операция за разделяне на етажа върху тях.
Код:
# 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)
Изход:
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'
Обяснение:
В горния кодов фрагмент сме дефинирали клас като IntStr който представя целочислените стойности като низове. След това създадохме два обекта от IntStr клас. Най-накрая разделихме етажа intOne обект от intTwo обект и се опита да отпечата резултата.
Горният резултат обаче показва a TypeError . Това съобщение за грешка разкрива това IntStr обекти не поддържат етажно разделение. Тази грешка има смисъл. Как персонализираният тип би имал някаква представа за обекти на низове, разделящи пода?
Въпреки това, както се оказва, можем да направим IntStr подпора на обект разделяне етаж.
Преди това научихме, когато се обаждаме на // оператор, ние наричаме __floordiv__() метод. Този метод се изпълнява някъде в класа на обекта. Например int обектите поддържат разделяне на етажа, тъй като int класът е приложил __floordiv__() метод.
Тези специални методи, като __floordiv__() , имат нещо удивително общо, че можем да внедрим тези методи в персонализирания клас. С други думи, можем да накараме персонализираните обекти да поддържат етажно разделяне в езика за програмиране Python.
Нека сега разгледаме следния пример, демонстриращ същото.
Пример 11.2:
В следващия пример ще приложим __floordiv__() метод в IntStr клас. След това ще създадем два обекта от този потребителски клас и ще извършим операция за разделяне на етажа върху тях.
Код:
# 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)
Изход:
17 // 4 = 4
Обяснение:
В горния кодов фрагмент сме дефинирали клас като IntStr който представя целочислените стойности като низове. Ние също така внедрихме __floordiv__() метод в този клас. Този метод приема стойността на числовия низ от себе си и от друг обект. Преобразувахме тези низови стойности в цели числа и извършихме разделяне на етажа между тях. След това преобразувахме резултата обратно в низ и създадохме нов IntStr обект. Създадохме инстанция на IntStr клас с два обекта и извърши операция за разделяне на етажа между тях. Най-накрая отпечатахме получената стойност за потребителите.
Сега, когато успешно разбираме метода за създаване на персонализиран клас за поддържане на разделяне на етажи.
Ако не ни харесва това, трябва да се обадим обект.вал за да видим резултата, можем да приложим __str__() метод, който директно връща стойността по време на печат.
Нека разгледаме следния пример, демонстриращ същото.
Пример 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)
Изход:
17 // 4 = 4
Обяснение:
В горния кодов фрагмент сме дефинирали клас като IntStr който представя целочислените стойности като низове. Ние също така внедрихме __floordiv__() метод в този клас. След това дефинирахме __str__() метод, който директно връща стойностите на низа по време на печат. Създадохме инстанция на IntStr клас с два обекта и извърши операция за разделяне на етажа между тях. Най-накрая отпечатахме получената стойност за потребителите.