Python round() függvény példákkal

Mi a round() függvény a következőben? Python?

Python A round() egy beépített függvény, amely a következővel érhető el: PythonEgy lebegőpontos számot ad vissza, amelyet a bemenetként megadott tizedesjegyekre kerekít.

Ha a kerekítendő tizedesjegyek nincsenek megadva, akkor az 0-nak számít, és a legközelebbi egész számra kerekedik.

Szintaxis

round(float_num, num_of_decimals)

paraméterek

• float_number: A kerekítendő lebegőpontos szám.
• tizedesjegyek_száma: (opcionális) A kerekítés során figyelembe veendő tizedesjegyek száma. Opcionális, és ha nincs megadva, akkor az alapértelmezett érték 0, és a kerekítés a legközelebbi egész számra történik.

Leírás

A round() metódus két argumentumot fogad el:

• a kerekítendő szám, és
• a tizedesjegyeket, amelyeket a kerekítés során figyelembe kell vennie.

A második argumentum opcionális, és ha nincs megadva, alapértelmezés szerint 0-ra van állítva. Ilyen esetben a legközelebbi egész számra kerekít, és a visszatérési típus is egész szám lesz.

A tizedesjegyek, azaz a második argumentum jelenléte esetén a megadott helyekre kerekít. A visszatérési típus float lesz.

Ha a megadott tizedesjegy utáni szám:

• >= 5, akkor + 1-et adunk a végső értékhez.
• < 5, akkor a végső érték változatlanul kerül visszaadásra, a megadott tizedesjegyekig.

Visszatérési érték

Egész értéket ad vissza, ha a num_of_decimals nincs megadva, és lebegőpontos értéket, ha a num_of_decimals meg van adva. Kérjük, vegye figyelembe, hogy az érték +1-re lesz kerekítve, ha a tizedesvessző utáni érték >= 5, egyébként a megadott értéket adja vissza.

Mekkora hatása lehet a kerekítésnek? (Kerekítés vs csonkítás)

A kerekítés hatásának legjobb példája a tőzsde. A múltban, azaz 1982-ben a Vancouver tőzsde (VSE) a részvényértékek három tizedesjegyre csonkolására szolgál minden egyes kereskedésnél.

Naponta közel 3000 alkalommal történt. A felhalmozódott csonkolás havi körülbelül 25 pont veszteséget eredményezett.

Az alábbiakban egy példa látható az értékek csonkolására a kerekítéssel szemben.

Tekintsük az alább generált lebegőpontos számokat részvényértékekként. Jelenleg 1 000 000 másodperces tartományra, 0.01 és 0.05 között generálom őket.

Példák:

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

A kerekítés hatásának bemutatására írtam egy rövid kódrészletet, amelyben először csak 3 tizedesjegyig használod a számokat, azaz 3 tizedesjegy után csonkolod a számot.

Megvan az eredeti összérték, a csonkolt értékekből származó összeg, valamint az eredeti és a csonkolt érték közötti különbség.

Ugyanazon a számhalmazon a round() metódust használtam 3 tizedesjegyig, és kiszámítottam az eredeti érték és a kerekített érték összegét és különbségét.

Íme a példa és a kimenet.

Példa 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)

output:

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

Az eredeti és a csonkolt érték közötti különbség 499.9016193868665, a round() függvényből pedig 0.04661938686695066.

A különbség nagyon nagynak tűnik, és a példa azt mutatja, hogy a round() metódus hogyan segít a közel pontosságú számításban.

Példa: Kerekítő úszó Numbers

Ebben a programban meglátjuk, hogyan működik a kerekítés lebegő számokon.

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

output:

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

Példa: Egész értékek kerekítése

Ha véletlenül a round()-ot használja egy egész értékhez, akkor csak visszaadja a számot változtatás nélkül.

# testing round() on a integer

num = 15

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

output:

The output is 15

Példa: Kerekítés negatívra Numbers

Nézzünk néhány példát arra, hogyan működik a kerekítés negatív számokon.

# testing round()

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

output:

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

Példa: Round NumPy tömbök

Hogyan kerekíted a NumPy-t? tömbök Python?

Ennek megoldására használhatjuk a NumPy modult, és a numpy.round() vagy a numpy.around() metódust használhatjuk, ahogy az az alábbi példában látható.

A numpy.round() használata

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

output:

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

Használhatjuk a numpy.around() függvényt is, amely ugyanazt az eredményt adja, mint a fent látható numpy.round() függvény.

Példa: Decimális modul

A round() függvényen kívül Python rendelkezik egy decimális modullal, amely segít a decimális számok pontosabb kezelésében.

A Decimal modul kerekítési típusokat tartalmaz, az alábbiak szerint:

• KEREK_MENNYEZET: a Végtelen felé fog fordulni.
• KEREKÍTÉS_LE: a nulla felé fogja kerekíteni az értéket.
• KEREK_EMELET: a -Végtelen felé fog kerekedni.
• KEREKÍTÉS_FÉL_LE: a legközelebbi, nullához közeli értékre fog kerekíteni.
• KEREK_FÉL_PÁROS: A legközelebbi páros egész számra kerekít.
• KEREKÍTÉS_FELÉ: a nullától eltérő legközelebbi értékre fog kerekíteni.
• RAZZIA: ott fog kerekíteni, ahol az érték eltér a nullától.

Tizedesben a quantize() metódus segít meghatározott számú tizedesjegyre kerekíteni, és megadhatja a használandó kerekítést, ahogy az az alábbi példában látható.

Példa: A round() és decimális módszerek használata

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)

output:

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

GYIK