Python round() funktsiooniga EXAMPLES

Round ()

Round() on pythoni sisseehitatud funktsioon. See tagastab teile ujukarvu, mis ümardatakse sisendiks antud kümnendkohtadeni.

Kui ümardatavaid kümnendkohti pole määratud, loetakse see nulliks ja ümardatakse lähima täisarvuni.

Süntaks

round(float_num, num_of_decimals)

parameetrid

• float_num: ujukarv, mis tuleb ümardada.
• kümnendkohtade_arv: (valikuline) ümardamisel arvesse võetavate kümnendkohtade arv. See on valikuline ja kui seda pole määratud, on see vaikimisi 0 ja ümardatakse lähima täisarvuni.

Kirjeldus

Round() meetodil on kaks argumenti

• ümardatav arv ja
• kümnendkohad, mida ta peaks ümardamisel arvestama.

Teine argument on valikuline ja vaikimisi väärtuseks 0, kui seda pole määratud, ning sel juhul ümardatakse see lähima täisarvuni ja tagastustüübiks on samuti täisarv.

Kui komakohad ehk teine ​​argument on olemas, ümardub see antud kohtade arvuni. Tagastamise tüüp on ujuki.

Kui number pärast koma on antud

• >=5 kui +1 lisatakse lõppväärtusele
• <5 kui lõplik väärtus tagastatakse, kuna see on kuni mainitud kümnendkohtadeni.

Tagastusväärtus

See tagastab täisarvu, kui kümnendkohtade_arv ei ole antud, ja ujuva väärtuse, kui on antud kümnendkohtade_arv. Pange tähele, et väärtus ümardatakse +1-ni, kui väärtus pärast koma on >=5, vastasel juhul tagastab see väärtuse nimetatud kümnendkohtadeni.

Kui palju võib ümardamine mõjutada? (Ümardamine vs kärpimine)

Parim näide ümardamise mõju näitamiseks on börsiturg. Minevikus ehk aastal 1982, Vancouveri börs (VSE): kasutatakse aktsiaväärtuste kärpimiseks iga tehingu puhul kolme kümnendkoha täpsusega.

Seda tehti iga päev ligi 3000 korda. Kogunenud kärpimised toovad kaasa umbes 25 punkti kaotuse kuus.

Allpool on näide väärtuste kärpimisest ümardamise suhtes.

Võtke allpool genereeritud ujukoma numbrid aktsiaväärtustena. Praegu genereerin seda paljude jaoks

1,000,000 0.01 0.05 sekundit vahemikus XNUMX kuni XNUMX.

Näited:

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

Ümardamise mõju näitamiseks olen kirjutanud väikese koodijupi, kus algul tuleb kasutada numbreid kuni 3 kohta pärast koma, st kärpida arvu 3 kohta pärast koma.

Mul on algne koguväärtus, kärbitud väärtuste koguväärtus ning algse ja kärbitud väärtuse erinevus.

Sama arvude komplekti puhul olen kasutanud meetodit round() kuni 3 kümnendkohani ning arvutanud summat ning algväärtuse ja ümardatud väärtuse vahet.

Siin on näide ja väljund
Näiteks 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)

Väljund:

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

Erinevus algse ja pärast kärpimist on 499.9016193868665 ja ümmarguselt on see 0.04661938686695066

Erinevus näib olevat väga suur ja näide näitab, kuidas ümardamise () meetod aitab lähedase täpsuse arvutamisel.

Näide: Ümardav ujuk Numbers

Selles programmis näeme, kuidas sõnu ujuvatel numbritel ümardatakse

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

Väljund:

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

Näide: täisarvu väärtuste ümardamine

Kui juhtub, et kasutate täisarvu puhul round(), tagastab see teile numbri ilma muudatusteta.

# testing round() on a integer

num = 15

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

Väljund:

The output is 15

Näide: ümardamine negatiivsele Numbers

Vaatame mõningaid näiteid selle kohta, kuidas ümardamine negatiivsete arvude korral toimib

# testing round()

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

Väljund:

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

Näide: ümarad numpy massiivid

Kuidas ümardada tuimust massiivid pythonis?

Selle lahendamiseks saame kasutada moodulit numpy ja meetodit numpy.round() või numpy.around(), nagu on näidatud allolevas näites.

Numpy.round() kasutamine

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

Väljund:

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

Võime kasutada ka numpy.around(), mis annab teile sama tulemuse, nagu on näidatud allolevas näites.

Näide: kümnendmoodul

Lisaks funktsioonile round() on pythonil kümnendmoodul, mis aitab kümnendnumbreid täpsemalt käsitleda.

Kümnendmoodulil on ümardamistüübid, nagu allpool näidatud:

• ROUND_CEILING: see ümardub lõpmatuse suunas,
• ROUND_DOWN: see ümardab väärtuse nulli suunas,
• ROUND_FLOOR: see ümardub -lõpmatuse suunas,
• ROUND_HALF_DOWN: see ümardub lähima väärtuseni, liikudes nulli suunas,
• ROUND_HALF_EVEN: see ümardub lähima väärtuseni lähima paarisarvuni,
• ROUND_HALF_UP: see ümardub lähima väärtusega nullist eemale
• ROUND_UP: see ümardab kohtades, kus väärtus nullist eemaldub.

Kümnendsüsteemis aitab meetod quantize() ümardada kindla arvu kümnendkohtadeni ja saate määrata kasutatava ümardamise, nagu on näidatud allolevas näites.
Näide:
Kasutades ümara() ja kümnendkoha meetodeid

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)

Väljund:

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

kokkuvõte

• Round(float_num, Num_of_decimals) on sisseehitatud funktsioon, mis on saadaval Pythoniga. See tagastab teile ujukarvu, mis ümardatakse sisendiks antud kümnendkohtadeni.
• float_num: ujukarv, mis tuleb ümardada.
• Num_of_decimals: see on kümnendkohtade arv, mida ümardamisel arvesse võtta.
• See tagastab täisarvu, kui kümnendkohtade_arv ei ole antud, ja ujuva väärtuse, kui on antud kümnendkohtade_arv.