Python round()-funktio EXAMPLESilla

Pyöristää()

Round() on sisäänrakennettu toiminto, joka on saatavana pythonissa. Se palauttaa float-luvun, joka pyöristetään syötteenä annettuihin desimaaleihin.

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

• float_num: pyöristettävä liukuluku.
• desimaalien_määrä: (valinnainen) Pyöristyksen aikana huomioon otettava desimaalien määrä. Se on valinnainen, ja jos sitä ei ole määritetty, sen oletusarvo on 0, ja pyöristys suoritetaan lähimpään kokonaislukuun.

Tuotetiedot

round()-menetelmässä on kaksi argumenttia

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

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

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

Jos desimaalin jälkeinen numero on annettu

• >=5 kuin + 1 lisätään lopulliseen arvoon
• <5, lopullinen arvo palautetaan, koska se on mainittujen desimaalien tarkkuudella.

Palautusarvo

Se palauttaa kokonaisluvun, jos desimaalien_määrä ei ole annettu, ja kelluvan arvon, jos desimaalien_määrä on annettu. Huomaa, että arvo pyöristetään arvoon +1, jos desimaalipilkun jälkeen oleva arvo on >=5, muuten se palauttaa arvon mainitun desimaalin tarkkuudella.

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

Paras esimerkki pyöristyksen vaikutuksesta on pörssimarkkinoilla. Aiemmin eli vuonna 1982 Vancouverin pörssi (VSE): käytetään katkaisemaan osakkeiden arvot kolmen desimaalin tarkkuudella kussakin kaupassa.

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

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

Tarkastellaan alla luotuja liukulukuja osakearvoina. Tällä hetkellä luon sitä useille

1,000,000 0.01 0.05 sekuntia välillä XNUMX ja XNUMX.

Esimerkkejä:

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

Pyöristyksen vaikutuksen havainnollistamiseksi olen kirjoittanut pienen koodinpätkän, jossa on aluksi käytettävä numeroita vain 3 desimaalin tarkkuudella eli katkaistava luku 3 desimaalin jälkeen.

Minulla on alkuperäinen kokonaisarvo, kokonaisarvo tulee katkaistuista arvoista ja ero alkuperäisen ja katkaistun arvon välillä.

Samalla numerosarjalla olen käyttänyt round()-menetelmää 3 desimaalin tarkkuudella ja laskenut alkuperäisen arvon ja pyöristetyn arvon välisen summan ja erotuksen.

Tässä on esimerkki ja tulos
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

Ero alkuperäisen ja katkaisun jälkeen on 499.9016193868665 ja pyöreän 0.04661938686695066

Ero näyttää olevan erittäin suuri, ja esimerkki osoittaa, kuinka round()-menetelmä auttaa laskemaan lähellä tarkkuutta.

Esimerkki: Pyöristävä kellunta Numbers

Tässä ohjelmassa näemme kuinka pyöristetään sanoja kelluvilla numeroilla

# 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ä, kuinka pyöristys 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

Kuinka pyöristää nukka taulukot pythonissa?

Tämän ratkaisemiseksi voimme käyttää numpy-moduulia ja numpy.round()- tai numpy.around()-metodia alla olevan esimerkin mukaisesti.

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 myös käyttää numpy.around(), joka antaa sinulle saman tuloksen kuin alla olevassa esimerkissä.

Esimerkki: Desimaalimoduuli

Pythonissa on round()-funktion lisäksi desimaalimoduuli, joka auttaa käsittelemään desimaalilukuja tarkemmin.

Desimaalimoduulissa on pyöristystyypit, kuten alla on esitetty:

• ROUND_CEILING: se pyörii kohti ääretöntä,
• ROUND_DOWN: se pyöristää arvon kohti nollaa,
• ROUND_FLOOR: se pyöristyy kohti -äärettömyyttä,
• ROUND_HALF_DOWN: se pyöristyy lähimpään arvoon nollaa kohti,
• ROUND_HALF_EVEN: se pyöristyy lähimpään, ja arvo tulee lähimpään parilliseen kokonaislukuun,
• ROUND_HALF_UP: pyöristetään lähimpään arvoon poissa nollasta
• ROUND_UP: se pyöristää, missä arvo poikkeaa 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

Yhteenveto

• Round(float_num, Sum_of_decimals) on sisäänrakennettu funktio, joka on saatavana pythonissa. Se palauttaa float-luvun, joka pyöristetään syötteenä annettuihin desimaaleihin.
• float_num: pyöristettävä liukuluku.
• Desimaalien_määrä: Tämä on pyöristyksen aikana huomioon otettava desimaalien määrä.
• Se palauttaa kokonaisluvun, jos desimaalien_määrä ei ole annettu, ja kelluvan arvon, jos desimaalien_määrä on annettu.