Python Функция round() с ПРИМЕРИ

Какво представлява функцията round() в Python?

Python round() е вградена функция, достъпна с PythonЩе ви върне число с плаваща запетая, което ще бъде закръглено до десетичните знаци, дадени като вход.

Ако десетичните знаци, които трябва да бъдат закръглени, не са посочени, се счита за 0 и ще се закръгли до най-близкото цяло число.

Синтаксис

round(float_num, num_of_decimals)

параметри

• номер_на_число_с_float: Числото с плаваща запетая, което да бъде закръглено.
• брой_десетични_значения: (по избор) Броят на десетичните знаци, които да се вземат предвид при закръгляването. Не е задължителен и ако не е посочен, по подразбиране е 0, а закръгляването се извършва до най-близкото цяло число.

Descriptйон

Методът round() приема два аргумента:

• числото, което трябва да се закръгли, и
• десетичните знаци, които трябва да вземе предвид при закръгляване.

Вторият аргумент е незадължителен и по подразбиране е 0, когато не е посочен, като в такъв случай той ще се закръгли до най-близкото цяло число, а типът на връщането също ще бъде цяло число.

Когато има десетични знаци, т.е. вторият аргумент, той ще се закръгли до дадения брой знаци. Върнатият тип ще бъде float.

Ако числото след десетичната запетая е:

• >= 5, тогава към крайната стойност ще се добави +1.
• < 5, тогава крайната стойност ще бъде върната такава, каквато е, до посочените десетични знаци.

Върната стойност

Ще върне цяло число, ако num_of_decimals не е даден, и стойност с плаваща запетая, ако num_of_decimals е даден. Моля, обърнете внимание, че стойността ще бъде закръглена до +1, ако стойността след десетичната запетая е >= ​​5, в противен случай ще върне стойността такава, каквато е, до посочените десетични знаци.

Колко въздействие може да има закръгляването? (Закръгляване срещу отрязване)

Най-добрият пример, който показва влиянието на закръгляването, е фондовият пазар. В миналото, т.е. през 1982 г., Фондова борса във Ванкувър (VSE), използвана за съкращаване на стойностите на акциите до три знака след десетичната запетая при всяка сделка.

Това се правеше почти 3000 пъти всеки ден. Натрупаните съкращения доведоха до загуба от около 25 точки на месец.

Пример за съкращаване на стойностите срещу закръгляване е показан по-долу.

Представете си генерираните по-долу числа с плаваща запетая като стойности на акции. В момента ги генерирам за диапазон от 1 000 000 секунди между 0.01 и 0.05.

Примери:

arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]

За да покажа влиянието на закръгляването, написах малък код, в който първоначално използвате числата само до 3 знака след десетичната запетая, т.е. отрязвате числото след 3 знака след десетичната запетая.

Имам първоначалната обща стойност, общата сума, получена от съкратените стойности, и разликата между първоначалната и съкратената стойност.

Върху същия набор от числа използвах метода round() до 3 знака след десетичната запетая и изчислих сумата и разликата между първоначалната стойност и закръглената стойност.

Ето примера и резултата.

Пример 1

import random

def truncate(num):
    return int(num * 1000) / 1000

arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]
sum_num = 0
sum_truncate = 0
for i in arr:
    sum_num = sum_num + i  
    sum_truncate = truncate(sum_truncate + i)
  
print("Testing by using truncating upto 3 decimal places")
print("The original sum is = ", sum_num)
print("The total using truncate = ", sum_truncate)
print("The difference from original - truncate = ", sum_num - sum_truncate)

print("\n\n")
print("Testing by using round() upto 3 decimal places")
sum_num1 = 0
sum_truncate1 = 0
for i in arr:
    sum_num1 = sum_num1 + i  
    sum_truncate1 = round(sum_truncate1 + i, 3)

print("The original sum is =", sum_num1)
print("The total using round = ", sum_truncate1)
print("The difference from original - round =", sum_num1 - sum_truncate1)

Изход:

Testing by using truncating upto 3 decimal places
The original sum is =  29985.958619386867
The total using truncate =  29486.057
The difference from original - truncate =  499.9016193868665

Testing by using round() up to 3 decimal places
The original sum is = 29985.958619386867
The total using round =  29985.912
The difference from original - round = 0.04661938686695066

Разликата между оригиналната и съкратената стойност е 499.9016193868665, а от round() е 0.04661938686695066.

Разликата изглежда много голяма и примерът показва как методът round() помага при изчисления с близка до точност точност.

Пример: Rounding Float Numbers

В тази програма ще видим как работи закръгляването на числа с плаваща плаваща величина.

# testing round()

float_num1 = 10.60 # here the value will be rounded to 11 as after the decimal point the number is 6 that is >5

float_num2 = 10.40 # here the value will be rounded to 10 as after the decimal point the number is 4 that is <=5

float_num3 = 10.3456 # here the value will be 10.35 as after the 2 decimal points the value >=5

float_num4 = 10.3445 #here the value will be 10.34 as after the 2 decimal points the value is <5

print("The rounded value without num_of_decimals is :", round(float_num1))
print("The rounded value without num_of_decimals is :", round(float_num2))
print("The rounded value with num_of_decimals as 2 is :", round(float_num3, 2))
print("The rounded value with num_of_decimals as 2 is :", round(float_num4, 2))

Изход:

The rounded value without num_of_decimals is : 11
The rounded value without num_of_decimals is : 10
The rounded value with num_of_decimals as 2 is : 10.35
The rounded value with num_of_decimals as 2 is : 10.34

Пример: Закръгляване на цели числа

Ако се случи да използвате round() за целочислена стойност, тя просто ще ви върне обратно числото без никакви промени.

# testing round() on a integer

num = 15

print("The output is", round(num))

Изход:

The output is 15

Пример: Закръгляване на отрицателно Numbers

Нека видим няколко примера за това как работи закръгляването на отрицателни числа.

# testing round()

num = -2.8
num1 = -1.5
print("The value after rounding is", round(num))
print("The value after rounding is", round(num1))

Изход:

C:\pythontest>python testround.py
The value after rounding is -3
The value after rounding is -2

Пример: Кръгли NumPy масиви

Как се закръглява NumPy масиви в Python?

За да решим това, можем да използваме модула NumPy и да използваме метода numpy.round() или numpy.around(), както е показано в примера по-долу.

Използване на numpy.round()

# testing round()
import numpy as np

arr = [-0.341111, 1.455098989, 4.232323, -0.3432326, 7.626632, 5.122323]

arr1 = np.round(arr, 2)

print(arr1)

Изход:

C:\pythontest>python testround.py
[-0.34  1.46  4.23 -0.34  7.63  5.12]

Можем също да използваме numpy.around(), което ви дава същия резултат като numpy.round(), показан по-горе.

Пример: Десетичен модул

В допълнение към функцията round(), Python има десетичен модул, който помага за по-точното боравене с десетични числа.

Модулът Decimal се предлага с типове закръгляване, както е показано по-долу:

• КРЪГЪЛ ТАВАН: ще се закръгли към безкрайността.
• ЗАКРЪГЛЯНЕ НАДОЛУ: ще закръгли стойността към нула.
• КРЪГЪЛ_ЕТАЖ: ще се закръгли към -безкрайност.
• ОКРУГЛА_ПОЛОВИНА_НАДОЛУ: ще се закръгли до най-близката стойност, насочена към нула.
• КРЪГ_ПОЛОВИНА_ЧЕТЕН: ще се закръгли до най-близката стойност, стигайки до най-близкото четно цяло число.
• КРЪГЪЛ_ПОЛОВИНА_НАГОРЕ: ще се закръгли до най-близката стойност, отдалечавайки се от нулата.
• ЗАКРУГЛЯВАНЕ: ще се закръгли там, където стойността ще се отклонява от нулата.

При десетични числа методът quantize() помага за закръгляване до фиксиран брой десетични знаци и можете да посочите закръгляването, което да се използва, както е показано в примера по-долу.

Пример: Използване на методите round() и decimal

import  decimal
round_num = 15.456

final_val = round(round_num, 2)

#Using decimal module
final_val1 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_CEILING)
final_val2 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_DOWN)
final_val3 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_FLOOR)
final_val4 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_DOWN)
final_val5 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_EVEN)
final_val6 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_UP)
final_val7 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_UP)

print("Using round()", final_val)
print("Using Decimal - ROUND_CEILING ",final_val1)
print("Using Decimal - ROUND_DOWN ",final_val2)
print("Using Decimal - ROUND_FLOOR ",final_val3)
print("Using Decimal - ROUND_HALF_DOWN ",final_val4)
print("Using Decimal - ROUND_HALF_EVEN ",final_val5)
print("Using Decimal - ROUND_HALF_UP ",final_val6)
print("Using Decimal - ROUND_UP ",final_val7)

Изход:

Using round() 15.46
Using Decimal - ROUND_CEILING  15.46
Using Decimal - ROUND_DOWN  15.45
Using Decimal - ROUND_FLOOR  15.45
Using Decimal - ROUND_HALF_DOWN  15.46
Using Decimal - ROUND_HALF_EVEN  15.46
Using Decimal - ROUND_HALF_UP  15.46
Using Decimal - ROUND_UP  15.46

Въпроси и Отговори