Python round() funkce s PŘÍKLADY

Kolo()

Round() je vestavěná funkce dostupná v pythonu. Vrátí vám plovoucí číslo, které bude zaokrouhleno na desetinná místa, která jsou uvedena jako vstup.

Pokud nejsou zaokrouhlena desetinná místa, považuje se to za 0 a zaokrouhlí se na nejbližší celé číslo.

Syntax

round(float_num, num_of_decimals)

parametry

• float_num: číslo float, které má být zaokrouhleno.
• num_of_decimals: (nepovinné) Počet desetinných míst, která mají být zohledněna při zaokrouhlování. Je volitelný, a pokud není zadán, jeho výchozí hodnota je 0 a zaokrouhlení se provádí na nejbližší celé číslo.

Description

Metoda round() má dva argumenty

• číslo, které se má zaokrouhlit, a
• desetinná místa, která by měla brát v úvahu při zaokrouhlování.

Druhý argument je volitelný a výchozí hodnota je 0, pokud není zadán, a v takovém případě se zaokrouhlí na nejbližší celé číslo a návratový typ bude také celé číslo.

Když jsou uvedena desetinná místa, tj. druhý argument, zaokrouhlí se na daný počet míst. Návratový typ bude plovoucí.

Pokud je uvedeno číslo za desetinným místem

• >=5 než + 1 bude připočteno ke konečné hodnotě
• <5, než se vrátí konečná hodnota, protože je až na uvedená desetinná místa.

Návratová hodnota

Vrátí celočíselnou hodnotu, pokud není zadáno num_of_decimals, a plovoucí hodnotu, pokud je zadáno num_of_decimals. Vezměte prosím na vědomí, že hodnota bude zaokrouhlena na +1, pokud je hodnota za desetinnou čárkou >=5, jinak vrátí hodnotu tak, jak je až na uvedená desetinná místa.

Jak velký dopad může mít zaokrouhlení? (zaokrouhlení vs zkrácení)

Nejlepší příklad, který ukazuje dopad zaokrouhlování, je pro burzovní trh. V minulosti, tj. v roce 1982, Vancouver Stock Exchange (VSE): používá se ke zkrácení hodnoty akcií na tři desetinná místa u každého obchodu.

Dělalo se to téměř 3000krát denně. Akumulovaná zkrácení vedou ke ztrátě přibližně 25 bodů za měsíc.

Příklad zkrácení hodnot versus zaokrouhlení je uveden níže.

Čísla s plovoucí desetinnou čárkou vygenerovaná níže považujte za hodnoty akcií. Právě teď to generuji pro řadu

1,000,000 0.01 0.05 sekund mezi XNUMX a XNUMX.

Příklady:

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

Abych ukázal dopad zaokrouhlování, napsal jsem malý kousek kódu, ve kterém je nejprve potřeba použít čísla pouze na 3 desetinná místa, tj. zkrátit číslo po 3 desetinných místech.

Mám původní celkovou hodnotu, součet pocházející z zkrácených hodnot a rozdíl mezi původní a zkrácenou hodnotou.

Na stejné sadě čísel jsem používal metodu round() až na 3 desetinná místa a vypočítával součet a rozdíl mezi původní hodnotou a zaokrouhlenou hodnotou.

Zde je příklad a výstup
Příklad 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)

Výstup:

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

Rozdíl mezi původní a po zkrácení je 499.9016193868665 a od zaokrouhlení je to 0.04661938686695066

Zdá se, že rozdíl je velmi velký a příklad ukazuje, jak metoda round() pomáhá při výpočtu blízko přesnosti.

Příklad: Zaokrouhlovací plovák Numbers

V tomto programu uvidíme, jak zaokrouhlovat slova na plovoucích číslech

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

Výstup:

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

Příklad: Zaokrouhlení celočíselných hodnot

Pokud náhodou použijete round() na celočíselnou hodnotu, vrátí vám to číslo zpět bez jakýchkoli změn.

# testing round() on a integer

num = 15

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

Výstup:

The output is 15

Příklad: Zaokrouhlení na záporné Numbers

Podívejme se na několik příkladů, jak zaokrouhlování funguje u záporných čísel

# testing round()

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

Výstup:

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

Příklad: Round Numpy Arrays

Jak zaokrouhlit numpy pole v pythonu?

K vyřešení tohoto problému můžeme použít modul numpy a použít metodu numpy.round() nebo numpy.around(), jak ukazuje příklad níže.

Použití 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)

Výstup:

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

Můžeme také použít numpy.around(), která vám poskytne stejný výsledek, jaký je znázorněn v příkladu níže.

Příklad: Desetinný modul

Kromě funkce round() má python dekadický modul, který pomáhá s přesnějším zpracováním desetinných čísel.

Modul Decimal se dodává s typy zaokrouhlování, jak je znázorněno níže:

• ROUND_CEILING: zaokrouhlí se směrem k nekonečnu,
• ROUND_DOWN: zaokrouhlí hodnotu směrem k nule,
• ROUND_FLOOR: zaokrouhlí se směrem k -nekonečnu,
• ROUND_HALF_DOWN: zaokrouhlí se na nejbližší hodnotu směrem k nule,
• ROUND_HALF_EVEN: zaokrouhlí se na nejbližší s hodnotou na nejbližší sudé celé číslo,
• ROUND_HALF_UP: zaokrouhlí se na nejbližší s hodnotou od nuly
• ROUND_UP: zaokrouhlí se tam, kde se hodnota bude vzdalovat od nuly.

V desítkové soustavě pomáhá metoda quantize() zaokrouhlovat na pevný počet desetinných míst a můžete zadat zaokrouhlování, které se má použít, jak je znázorněno v příkladu níže.
Příklad:
Použití round() a desítkových metod

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)

Výstup:

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

Shrnutí

• Round(float_num, Num_of_decimals) je vestavěná funkce dostupná v pythonu. Vrátí vám plovoucí číslo, které bude zaokrouhleno na desetinná místa, která jsou uvedena jako vstup.
• float_num: číslo float, které má být zaokrouhleno.
• Num_of_decimals: Je to počet desetinných míst, který je třeba vzít v úvahu při zaokrouhlování.
• Vrátí celočíselnou hodnotu, pokud není zadáno num_of_decimals, a plovoucí hodnotu, pokud je zadáno num_of_decimals.