Funkce Round () Pythonu s PŘÍKLADY

Obsah:

Anonim

Kolo()

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

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

V tomto výukovém programu pro Python se naučíte:

  • Kolo()
  • Syntax:
  • Jaký dopad může mít zaokrouhlování? (Zaokrouhlování vs Zkrácení)
  • Příklad: Zaokrouhlování čísel float
  • Příklad: Zaokrouhlování celočíselných hodnot
  • Příklad: Zaokrouhlování na záporná čísla
  • Příklad: Round Numpy Arrays
  • Příklad: Desetinný modul

Syntax:

round(float_num, num_of_decimals)

Parametry

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

Popis

Metoda round () trvá dva argumenty

  • číslo, které má být zaokrouhleno, a
  • desetinná místa, která by měla při zaokrouhlování zohlednit.

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.

Pokud jsou k dispozici desetinná místa, tj. Druhý argument, zaokrouhlí se na počet zadaných míst. Návratový typ bude float.

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

  • > = 5 než +1 bude přidáno k 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ána hodnota num_of_decimals, a plovoucí hodnotu, pokud je uvedena hodnota num_of_decimals. Upozorňujeme, že hodnota bude zaokrouhlena na +1, pokud je hodnota za desetinnou čárkou> = 5, jinak vrátí hodnotu, protože je až na uvedená desetinná místa.

Jaký dopad může mít zaokrouhlování? (Zaokrouhlování vs Zkrácení)

Nejlepším příkladem k prokázání dopadu zaokrouhlování je trh burzy. V minulosti, tj. V roce 1982, se Vancouver Stock Exchange (VSE) používala ke zkrácení hodnot akcií na tři desetinná místa u každého obchodu.

Dělo se to téměř 3000krát každý den. Shromážděné zkrácení vedou ke ztrátě přibližně 25 bodů za měsíc.

Níže je uveden příklad zkrácení hodnot oproti zaokrouhlení.

Zvažte čísla s plovoucí desetinnou čárkou generovaná níže jako hodnoty akcií. Právě teď to generuji pro řadu

1 000 000 sekund mezi 0,01 a 0,05.

Příklady:

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

Chcete-li ukázat dopad zaokrouhlování, napsal jsem malý kousek kódu, kde nejprve musíte použít čísla až na 3 desetinná místa, tj. Zkrácení čísla za 3 desetinná místa.

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

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

Tady je příklad a výstup

Příklad 1

import randomdef truncate(num):return int(num * 1000) / 1000arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]sum_num = 0sum_truncate = 0for i in arr:sum_num = sum_num + isum_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 = 0sum_truncate1 = 0for i in arr:sum_num1 = sum_num1 + isum_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 placesThe original sum is = 29985.958619386867The total using truncate = 29486.057The difference from original - truncate = 499.9016193868665Testing by using round() up to 3 decimal placesThe original sum is = 29985.958619386867The total using round = 29985.912The difference from original - round = 0.04661938686695066

Rozdíl mezi původním a po zkrácení je 499,9016193868665 a od kulatého je to 0,04661938686695066

Rozdíl se zdá být velmi velký a příklad ukazuje, jak metoda round () pomáhá při výpočtu téměř přesnosti.

Příklad: Zaokrouhlování čísel float

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

# 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 >5float_num2 = 10.40 # here the value will be rounded to 10 as after the decimal point the number is 4 that is <=5float_num3 = 10.3456 # here the value will be 10.35 as after the 2 decimal points the value >=5float_num4 = 10.3445 #here the value will be 10.34 as after the 2 decimal points the value is <5print("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 : 11The rounded value without num_of_decimals is : 10The rounded value with num_of_decimals as 2 is : 10.35The rounded value with num_of_decimals as 2 is : 10.34

Příklad: Zaokrouhlování celočíselných hodnot

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

# testing round() on a integernum = 15print("The output is", round(num))

Výstup:

The output is 15

Příklad: Zaokrouhlování na záporná čísla

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

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

Výstup:

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

Příklad: Round Numpy Arrays

Jak zaokrouhlit numpy pole v pythonu?

Abychom to vyřešili, můžeme využít modul numpy a použít metodu numpy.round () nebo numpy.around (), jak je ukázáno v níže uvedeném příkladu.

Používání numpy.round ()

# testing round()import numpy as nparr = [-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 (), což vám dá stejný výsledek, jaký je uveden v níže uvedeném příkladu.

Příklad: Desetinný modul

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

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

  • ROUND_CEILING: zaokrouhlí se na nekonečno,
  • ROUND_DOWN: zaokrouhlí hodnotu na nulu,
  • ROUND_FLOOR: zaokrouhlí se na -Infinity,
  • 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 bude hodnota klesat od nuly.

V desítkové soustavě metoda quantize () pomáhá zaokrouhlit na pevný počet desetinných míst a můžete určit zaokrouhlení, které se má použít, jak je znázorněno v níže uvedeném příkladu.

Příklad:

Použití metod round () a decimal

import decimalround_num = 15.456final_val = round(round_num, 2)#Using decimal modulefinal_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.46Using Decimal - ROUND_CEILING 15.46Using Decimal - ROUND_DOWN 15.45Using Decimal - ROUND_FLOOR 15.45Using Decimal - ROUND_HALF_DOWN 15.46Using Decimal - ROUND_HALF_EVEN 15.46Using Decimal - ROUND_HALF_UP 15.46Using Decimal - ROUND_UP 15.46

Souhrn:

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