Python round() funksjon med EKSEMPLER

by: Logan Young Logan Young
Hours oppdatert

Rund()

Round() er en innebygd funksjon tilgjengelig med python. Det vil returnere 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

  • float_num: flyttallet som skal avrundes.
  • num_of_desimals: (valgfritt) Antall desimaler som skal vurderes ved avrunding. Det er valgfritt, og hvis det ikke er spesifisert, er det standard 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 er standard til 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 desimaltegnet

  • >=5 enn + 1 vil bli lagt til den endelige verdien
  • <5 enn den endelige verdien vil returnere da den er opp til desimalene som er nevnt.

Returverdi

Den vil returnere en heltallsverdi hvis num_of_desimals ikke er gitt og en flytende verdi hvis num_of_desimals er gitt. Vær oppmerksom på at verdien vil bli avrundet til +1 hvis verdien etter desimaltegn er >=5, ellers vil den returnere verdien ettersom den er opp til desimalene som er nevnt.

RELATERTE ARTIKLER

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

Det beste eksemplet for å vise effekten av avrunding er for børsmarkedet. I det siste, dvs. i år 1982, ble 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ører til et tap på rundt 25 poeng per måned.

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

Betrakt flyttallstallene generert nedenfor som aksjeverdier. Akkurat nå genererer jeg det for en rekke

1,000,000 0.01 0.05 sekunder mellom XNUMX og XNUMX.

Eksempler:

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

For å vise virkningen av avrunding har jeg skrevet en liten kode hvor du først må bruke tallene opp til bare 3 desimaler, dvs. avkorte tallet etter 3 desimaler.

Jeg har den opprinnelige totalverdien, summen kommer fra trunkerte verdier og forskjellen mellom original og trunkert verdi.

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

Her er eksemplet og utgangen
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 original og etter trunkering er 499.9016193868665, og fra runde er den 0.04661938686695066

Forskjellen ser ut til å være veldig stor, og eksemplet viser hvordan metoden round() hjelper til med å beregne nær nøyaktighet.

Eksempel: Rounding Float Numbers

I dette programmet skal vi se hvordan ord avrundes 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 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: Round Numpy Arrays

Hvordan runde numpy arrays i python?

For å løse dette kan vi bruke numpy-modulen og bruke numpy.round()- eller numpy.around()-metoden, som vist i eksempelet 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 vist i eksempelet nedenfor.

Eksempel: Desimalmodul

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

Desimalmodulen kommer med avrundingstyper, som vist nedenfor:

  • ROUND_CEILING: den vil runde mot uendelig,
  • ROUND_DOWN: det vil runde verdien mot null,
  • ROUND_FLOOR: den vil runde mot -Uendelig,
  • ROUND_HALF_DOWN: den vil runde av til nærmeste verdi mot null,
  • ROUND_HALF_EVEN: den vil runde av til nærmeste med verdien som går til nærmeste partall,
  • ROUND_HALF_UP: den rundes av til nærmeste med verdi som går bort fra null
  • ROUND_UP: den vil runde der verdien vil gå 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

Sammendrag

  • Round(float_num, Num_of_desimals) er en innebygd funksjon tilgjengelig med python. Det vil returnere flytnummeret som vil bli avrundet til desimalene som er gitt som input.
  • float_num: flyttallet som skal avrundes.
  • Antall_desimaler: Det er antallet desimaler som skal vurderes ved avrunding.
  • Den vil returnere en heltallsverdi hvis num_of_desimals ikke er gitt og en flytende verdi hvis num_of_desimals er gitt.

Oppsummer dette innlegget med: