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

Кръгъл()

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

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

Синтаксис

round(float_num, num_of_decimals)

параметри

  • float_num: числото на float, което трябва да бъде закръглено.
  • num_of_decimals: (по избор) Броят на десетичните знаци, които трябва да се вземат предвид при закръгляване. Не е задължително и ако не е посочено, по подразбиране е 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 секунди между XNUMX и XNUMX.

Примери:

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, а от кръга е 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(), което ви дава същия резултат, както е показано в примера по-долу.

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

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

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

  • ROUND_CEILING: ще се закръгли към безкрайност,
  • ROUND_DOWN: ще закръгли стойността към нула,
  • ROUND_FLOOR: ще се закръгли към -безкрайност,
  • ROUND_HALF_DOWN: ще закръгли до най-близката стойност към нула,
  • ROUND_HALF_EVEN: ще се закръгли до най-близкото със стойност към най-близкото четно цяло число,
  • ROUND_HALF_UP: ще се закръгли до най-близкото със стойност, която се отклонява от нула
  • ROUND_UP: ще закръгли там, където стойността ще се отклони от нула.

При десетични числа методът 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

Oбобщение

  • Round(float_num, Num_of_decimals) е вградена функция, достъпна с python. Той ще ви върне числото с плаваща запетая, което ще бъде закръглено до десетичните знаци, които са дадени като вход.
  • float_num: числото на float, което трябва да бъде закръглено.
  • Num_of_decimals: Това е броят на десетичните знаци, които трябва да се вземат предвид при закръгляване.
  • Той ще върне целочислена стойност, ако num_of_decimals не е даден, и стойност с плаваща единица, ако num_of_decimals е даден.