Python round()-funksjon med EKSEMPLER

Hva er round()-funksjonen i Python?

Python round() er en innebygd funksjon tilgjengelig med PythonDen vil returnere deg et flyttall som vil bli avrundet til desimalene som er gitt som input.

Hvis desimalplassene som skal avrundes ikke er spesifisert, regnes det som 0, og det vil avrundes til nærmeste heltall.

syntax

round(float_num, num_of_decimals)

Parametre

• flyttall: Flyttallet som skal avrundes.
• antall_desimaler: (valgfritt) Antall desimaler som skal tas i betraktning ved avrunding. Dette er valgfritt, og hvis ikke spesifisert, settes standardverdien til 0, og avrundingen gjøres til nærmeste heltall.

Tekniske beskrivelser

round()-metoden tar to argumenter:

• tallet som skal avrundes, og
• desimalene den bør vurdere ved avrunding.

Det andre argumentet er valgfritt og har som standard 0 når det ikke er spesifisert, og i slike tilfeller vil det runde av til nærmeste heltall, og returtypen vil også være et heltall.

Når desimalplassene, dvs. det andre argumentet, er tilstede, vil det avrundes til antall oppgitte plasser. Returtypen vil være en float.

Hvis tallet etter desimalen som er oppgitt er:

• >= 5, så vil + 1 bli lagt til den endelige verdien.
• < 5, så vil den endelige verdien returneres som den er, opptil de nevnte desimalene.

Returverdi

Den vil returnere en heltallsverdi hvis num_of_decimals ikke er oppgitt, og en flyttallsverdi hvis num_of_decimals er oppgitt. Vær oppmerksom på at verdien vil bli avrundet til +1 hvis verdien etter desimaltegnet er >= 5, ellers vil den returnere verdien som den er, opp til de nevnte desimalene.

Hvor stor innvirkning kan avrunding ha? (Avrunding vs trunkering)

Det beste eksemplet på å vise effekten av avrunding er børsmarkedet. Tidligere, dvs. i år 1982, Vancouver børs (VSE) brukes til å avkorte aksjeverdiene til tre desimaler på hver handel.

Det ble gjort nesten 3000 ganger hver dag. De akkumulerte avkortningene førte til et tap på rundt 25 poeng per måned.

Et eksempel på avkorting av verdiene kontra avrunding er vist nedenfor.

Tenk på flyttallene som genereres nedenfor som standardverdier. Akkurat nå genererer jeg dem for et område på 1 000 000 sekunder mellom 0.01 og 0.05.

Eksempler:

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

For å vise effekten av avrunding har jeg skrevet et lite kodestykke der du først bruker tallene opptil bare 3 desimaler, dvs. avkorter tallet etter 3 desimaler.

Jeg har den opprinnelige totalverdien, totalen som kommer fra de avkortede verdiene, og differansen mellom den opprinnelige og den avkortede verdien.

På det samme settet med tall har jeg brukt round()-metoden opptil 3 desimaler og beregnet summen og differansen mellom den opprinnelige verdien og den avrundede verdien.

Her er eksemplet og resultatet.

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

Utgang:

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

Forskjellen mellom den opprinnelige og den avkortede verdien er 499.9016193868665, og fra round() er den 0.04661938686695066.

Forskjellen ser ut til å være veldig stor, og eksemplet viser hvordan round()-metoden bidrar til å beregne tilnærmet nøyaktighet.

Eksempel: Rounding Float Numbers

I dette programmet skal vi se hvordan avrunding fungerer på flytende tall.

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

Utgang:

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

Eksempel: Avrunding av heltallsverdier

Hvis du tilfeldigvis bruker round() på en heltallsverdi, vil den bare returnere tallet tilbake uten endringer.

# testing round() on a integer

num = 15

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

Utgang:

The output is 15

Eksempel: Avrunding på negativ Numbers

La oss se på noen eksempler på hvordan avrunding fungerer på negative tall.

# testing round()

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

Utgang:

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

Eksempel: Avrundede NumPy-matriser

Hvordan runder du NumPy arrayer i Python?

For å løse dette kan vi bruke NumPy-modulen og bruke numpy.round()- eller numpy.around()-metoden, som vist i eksemplet nedenfor.

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

Utgang:

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

Vi kan også bruke numpy.around(), som gir deg samme resultat som numpy.round() vist ovenfor.

Eksempel: Desimalmodul

I tillegg til round()-funksjonen, Python har en desimalmodul som hjelper med å håndtere desimaltall mer nøyaktig.

Desimalmodulen leveres med avrundingstyper, som vist nedenfor:

• RUNDT_TAK: den vil runde mot uendelig.
• AVRUND_NED: den vil runde verdien mot null.
• RUND_ETASJE: den vil runde mot -uendeligheten.
• RUND_HALV_NED: Den vil runde av til nærmeste verdi mot null.
• RUND_HALV_PARTY: den vil runde av til nærmeste verdi og gå videre til nærmeste partall.
• RUND_HALV_OPP: Den vil runde av til nærmeste verdi som går bort fra null.
• AVRUND OPP: den vil runde av der verdien går bort fra null.

I desimal hjelper quantize()-metoden å runde av til et fast antall desimaler, og du kan spesifisere avrundingen som skal brukes, som vist i eksempelet nedenfor.

Eksempel: Bruke round() og desimalmetoder

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)

Utgang:

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

Spørsmål og svar