Pythonová funkcia round () s PRÍKLADMI

Obsah:

Anonim

Okrúhly()

Round () je vstavaná funkcia dostupná pre python. Vráti vám float číslo, ktoré bude zaokrúhlené na desatinné miesta, ktoré sú uvedené ako vstup.

Ak nie sú zadané desatinné miesta, ktoré sa majú zaokrúhliť, považuje sa to za 0 a zaokrúhli sa na najbližšie celé číslo.

V tomto výučbe pre Python sa dozviete:

  • Okrúhly()
  • Syntax:
  • Aký dopad môže mať zaokrúhlenie? (Zaokrúhlenie vs skrátenie)
  • Príklad: Zaokrúhľovanie plávajúcich čísel
  • Príklad: Zaokrúhľovanie celočíselných hodnôt
  • Príklad: Zaokrúhľovanie na záporné čísla
  • Príklad: okrúhle polia Numpy
  • Príklad: desatinný modul

Syntax:

round(float_num, num_of_decimals)

Parametre

  • float_num: číslo float, ktoré sa má zaokrúhliť.
  • num_of_decimals: (voliteľné) Počet desatinných miest, ktoré sa majú zohľadniť pri zaokrúhľovaní. Je voliteľný, a ak nie je uvedený, má predvolenú hodnotu 0 a zaokrúhľovanie sa vykonáva na najbližšie celé číslo.

Popis

Metóda round () má dva argumenty

  • - číslo, ktoré sa má zaokrúhliť, a -
  • desatinné miesta, ktoré by mala brať do úvahy pri zaokrúhľovaní.

Druhý argument je voliteľný a predvolene má hodnotu 0, ak nie je zadaná, a v takom prípade sa zaokrúhli na najbližšie celé číslo a návratový typ bude tiež celé číslo.

Ak sú prítomné desatinné miesta, tj. Druhý argument, zaokrúhli sa na počet zadaných miest. Návratový typ bude plavák.

Ak je číslo za desatinným miestom dané

  • > = 5 ako +1 bude pridaných k výslednej hodnote
  • <5 než sa vráti konečná hodnota, pretože je to až do spomenutých desatinných miest.

Návratová hodnota

Vráti celočíselnú hodnotu, ak nie je uvedený num_of_decimals, a plávajúcu hodnotu, ak je uvedený num_of_decimals. Hodnota bude zaokrúhlená na +1, ak je hodnota za desatinnou čiarkou> = 5, inak vráti hodnotu, ktorá je až na uvedené desatinné miesta.

Aký dopad môže mať zaokrúhlenie? (Zaokrúhlenie vs skrátenie)

Najlepším príkladom na preukázanie vplyvu zaokrúhľovania je trh cenných papierov. V minulosti, tj. V roku 1982, sa Vancouverská burza cenných papierov (VSE) používala na skrátenie hodnôt akcií na tri desatinné miesta pri každom obchode.

Robilo sa to takmer 3000 krát každý deň. Akumulované skrátenia vedú k strate okolo 25 bodov mesačne.

Nižšie je uvedený príklad skrátenia hodnôt oproti zaokrúhľovaniu.

Zvážte nižšie uvedené čísla s pohyblivou rádovou čiarkou ako hodnoty akcií. Práve teraz ho generujem pre celý rad

1 000 000 sekúnd medzi 0,01 a 0,05.

Príklady:

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

Aby som ukázal vplyv zaokrúhľovania, napísal som malý kúsok kódu, v ktorom najskôr musíte použiť čísla až na 3 desatinné miesta, tj skrátiť číslo na 3 desatinné miesta.

Mám pôvodnú celkovú hodnotu, celkovú hodnotu pochádzajúcu zo skrátených hodnôt a rozdiel medzi pôvodnou a skrátenou hodnotou.

Na tej istej množine čísel používam metódu round () až na 3 desatinné miesta a počítam súčet a rozdiel medzi pôvodnou hodnotou a zaokrúhlenou hodnotou.

Tu je príklad a výstup

Prí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ýkon:

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

Rozdiel medzi pôvodným a po skrátení je 499,9016193868665 a od okrúhleho je to 0,04661938686695066

Rozdiel sa javí ako veľmi veľký a príklad ukazuje, ako metóda round () pomáha pri výpočte blízkej presnosti.

Príklad: Zaokrúhľovanie plávajúcich čísel

V tomto programe uvidíme, ako sa slová zaokrúhľujú na plávajúce čí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ýkon:

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

Príklad: Zaokrúhľovanie celočíselných hodnôt

Ak náhodou použijete round () na celočíselnú hodnotu, vráti vám číslo bez akýchkoľvek zmien.

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

Výkon:

The output is 15

Príklad: Zaokrúhľovanie na záporné čísla

Pozrime sa na niekoľko príkladov, ako zaokrúhľovanie 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ýkon:

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

Príklad: okrúhle polia Numpy

Ako zaokrúhliť početné polia v Pythone?

Na vyriešenie tohto problému môžeme použiť modul numpy a použiť metódu numpy.round () alebo numpy.around (), ako je uvedené v príklade nižšie.

Používanie 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ýkon:

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

Môžeme tiež použiť numpy.around (), ktoré vám poskytne rovnaký výsledok, aký je uvedený v príklade nižšie.

Príklad: desatinný modul

Okrem funkcie round () má python desatinný modul, ktorý pomáha pri presnejšej manipulácii s desatinnými číslami.

Modul Decimal je dodávaný s typmi zaokrúhľovania, ako je uvedené nižšie:

  • ROUND_CEILING: zaokrúhli sa na nekonečno,
  • ROUND_DOWN: zaokrúhli hodnotu na nulu,
  • ROUND_FLOOR: zaokrúhli sa na -Infinity,
  • ROUND_HALF_DOWN: zaokrúhli sa na najbližšiu hodnotu smerom k nule,
  • ROUND_HALF_EVEN: zaokrúhli sa na najbližšie s hodnotou idúcou po najbližšie celé párne číslo,
  • ROUND_HALF_UP: zaokrúhli sa na najbližšie s hodnotou od nuly
  • ROUND_UP: zaokrúhli sa tam, kde bude hodnota klesať od nuly.

V desiatkovej sústave pomáha metóda quantize () zaokrúhľovať na pevný počet desatinných miest a môžete určiť zaokrúhlenie, ktoré sa má použiť, ako je uvedené v príklade nižšie.

Príklad:

Použitie metód zaokrúhľovania () a desatinných miest

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ýkon:

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

Zhrnutie:

  • Round (float_num, Num_of_decimals) je zabudovaná funkcia dostupná v pythone. Vráti vám číslo float, ktoré bude zaokrúhlené na desatinné miesta, ktoré sú uvedené ako vstup.
  • float_num: číslo float, ktoré sa má zaokrúhliť.
  • Num_of_decimals: Je to počet desatinných miest, ktoré sa majú brať do úvahy pri zaokrúhľovaní.
  • Vráti celočíselnú hodnotu, ak nie je uvedený num_of_decimals, a plávajúcu hodnotu, ak je uvedený num_of_decimals.