Python round()-funktio esimerkkeineen

Mikä on round()-funktio funktiossa Python?

Python round() on sisäänrakennettu funktio, joka on käytettävissä PythonSe palauttaa liukulukun, joka pyöristetään syötteenä annettujen desimaalien tarkkuudelle.

Jos pyöristettävää desimaalipistettä ei ole määritetty, sen katsotaan olevan 0, ja se pyöristetään lähimpään kokonaislukuun.

Syntaksi

round(float_num, num_of_decimals)

parametrit

• liukuluku: Pyöristettävä liukuluku.
• desimaalien_määrä: (valinnainen) Pyöristyksessä huomioon otettavien desimaalien lukumäärä. Tämä on valinnainen, ja jos sitä ei ole määritetty, oletusarvo on 0 ja pyöristys tehdään lähimpään kokonaislukuun.

Tuotetiedot

round()-metodi ottaa vastaan ​​kaksi argumenttia:

• pyöristettävä luku ja
• desimaalit, joita sen tulee ottaa huomioon pyöristyksen aikana.

Toinen argumentti on valinnainen ja sen oletusarvo on 0, jos sitä ei ole määritetty. Tällaisessa tapauksessa se pyöristetään lähimpään kokonaislukuun ja paluutyyppi on myös kokonaisluku.

Kun desimaalit eli toinen argumentti on olemassa, pyöristetään annettujen paikkojen lukumäärään. Palautustyyppi on float.

Jos annetun desimaalipilkun jälkeinen luku on:

• >= 5, niin lopulliseen arvoon lisätään + 1.
• < 5, niin lopullinen arvo palautetaan sellaisenaan, mainittuihin desimaalien tarkkuudella.

Palautusarvo

Se palauttaa kokonaisluvun, jos desimaalien_määrää ei ole annettu, ja liukulukuarvon, jos desimaalien_määrä on annettu. Huomaa, että arvo pyöristetään +1:een, jos desimaalipilkun jälkeinen arvo on >= 5. Muussa tapauksessa se palauttaa arvon sellaisenaan, mainittuihin desimaalien tarkkuudella.

Kuinka paljon vaikutusta pyöristyksellä voi olla? (pyöristys vs katkaisu)

Paras esimerkki pyöristämisen vaikutuksesta on pörssimarkkinat. Aiemmin, eli vuonna 1982, Vancouverin pörssi (VSE) käytetään osakkeiden arvojen katkaisemiseen kolmen desimaalin tarkkuudella jokaisessa kaupassa.

Se tehtiin lähes 3000 kertaa päivässä. Kertyneet katkaisut johtivat noin 25 pisteen menetykseen kuukaudessa.

Alla on esimerkki arvojen lyhentämisestä pyöristykseen verrattuna.

Tarkastellaan alla olevia liukulukuja osakearvoina. Tällä hetkellä luon niitä miljoonan sekunnin ajalle välillä 0.01 ja 0.05.

Esimerkkejä:

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

Pyöristämisen vaikutuksen havainnollistamiseksi olen kirjoittanut pienen koodinpätkän, jossa aluksi käytetään numeroita vain kolmen desimaalin tarkkuudella eli katkaistaan ​​luku kolmen desimaalin jälkeen.

Minulla on alkuperäinen kokonaisarvo, katkaistujen arvojen kokonaisarvo sekä alkuperäisen ja katkaistun arvon välinen erotus.

Samoille lukujoukoille olen käyttänyt round()-metodia kolmen desimaalin tarkkuudella ja laskenut alkuperäisen arvon ja pyöristettyjen lukujen summan ja erotuksen.

Tässä on esimerkki ja tuloste.

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

lähtö:

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

Alkuperäisen ja katkaistun arvon välinen erotus on 499.9016193868665, ja round()-funktion perusteella se on 0.04661938686695066.

Ero näyttää olevan erittäin suuri, ja esimerkki osoittaa, kuinka round()-metodi auttaa laskemaan lähes tarkasti.

Esimerkki: Pyöristävä kellunta Numbers

Tässä ohjelmassa näemme, miten pyöristäminen toimii kelluvien lukujen kanssa.

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

lähtö:

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

Esimerkki: Kokonaislukuarvojen pyöristys

Jos satut käyttämään round():ta kokonaislukuarvona, se palauttaa sinulle luvun ilman muutoksia.

# testing round() on a integer

num = 15

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

lähtö:

The output is 15

Esimerkki: Negatiivin pyöristys Numbers

Katsotaanpa muutamia esimerkkejä siitä, miten pyöristäminen toimii negatiivisilla luvuilla.

# testing round()

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

lähtö:

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

Esimerkki: Pyöreät NumPy-taulukot

Miten pyöristät NumPyn taulukot Python?

Ratkaistaksemme tämän voimme hyödyntää NumPy-moduulia ja käyttää numpy.round()- tai numpy.around()-metodia, kuten alla olevassa esimerkissä on esitetty.

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)

lähtö:

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

Voimme käyttää myös numpy.around()-funktiota, joka antaa saman tuloksen kuin yllä esitetty numpy.round().

Esimerkki: Desimaalimoduuli

round()-funktion lisäksi Python sisältää desimaalimoduulin, joka auttaa käsittelemään desimaalilukuja tarkemmin.

Desimaalimoduuli sisältää pyöristystyyppejä, kuten alla on esitetty:

• PYÖREÄ_KATTO: se pyörii kohti äärettömyyttä.
• PYÖRISTÄ_ALAS: se pyöristää arvon kohti nollaa.
• PYÖREÄ_KERROS: se pyörii kohti -äärettömyyttä.
• PUOLIKAS_ALAS: se pyöristyy lähimpään nollaa kohti menevään arvoon.
• PUOLIKAS_PARILLINEN: se pyöristyy lähimpään arvoon ja pyöristyy lähimpään parilliseen kokonaislukuun.
• PYÖRISTÄ_PUOLIKSI_YLÖS: se pyöristyy lähimpään nollasta poispäin olevaan arvoon.
• RATSIA: se pyöristyy kohdassa, jossa arvo poistuu nollasta.

Desimaalimuodossa quantize()-menetelmä auttaa pyöristämään kiinteään määrään desimaaleja, ja voit määrittää käytettävän pyöristyksen alla olevan esimerkin mukaisesti.

Esimerkiksi: Pyöreä()- ja desimaalimenetelmillä

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)

lähtö:

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

UKK