Python round() függvény EXAMPLES-szel
Logan Young
Kerek ()
A Round() egy beépített függvény, amely elérhető a pythonnal. Egy 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_num: a kerekítendő float szám.
- decimális_szám: (nem kötelező) A kerekítés során figyelembe veendő tizedesjegyek száma. Ez nem kötelező, és ha nincs megadva, akkor alapértelmezés szerint 0, és a kerekítés a legközelebbi egész számra történik.
Leírás
A round() metódusnak két argumentuma van
- a kerekítendő számot és
- a tizedesjegyeket, amelyeket a kerekítés során figyelembe kell vennie.
A második argumentum nem kötelező, és alapértelmezés szerint 0, ha nincs megadva, és ebben az 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, mint + 1 hozzáadódik a végső értékhez
- <5, mint a végső érték jelenik meg, mivel az említett tizedesjegyekig terjed.
Visszatérési érték
Egész értéket ad vissza, ha a tizedesek_száma nincs megadva, és lebegő értéket, ha a tizedesek_száma adott. Kérjük, vegye figyelembe, hogy az érték +1-re kerekedik, ha a tizedesvessző utáni érték >=5, különben az említett tizedesjegyekig visszaadja az értéket.
Mekkora hatása lehet a kerekítésnek? (Kerekítés vs csonkítás)
A kerekítés hatásának bemutatására a legjobb példa a tőzsdepiac. A múltban, azaz 1982-ben a Vancouver tőzsde (VSE): a részvényértékek három tizedesjegyre való csonkolására szolgál minden egyes ügyletnél.
Naponta majdnem 3000-szer csinálták meg. A felhalmozott csonkolások havonta körülbelül 25 pont veszteséget okoznak.
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ékeknek. Jelenleg egy sorhoz generálom
1,000,000 0.01 0.05 másodperc XNUMX és XNUMX között.
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 kis kódrészletet, amelyben eleinte csak 3 tizedesjegyig kell a számokat használni, azaz a számot 3 tizedesjegy után csonkolni.
Megvan az eredeti összérték, a csonka értékekből származó végösszeg, valamint az eredeti és a csonka érték közötti különbség.
Ugyanazon a számkészleten a round() módszert használtam 3 tizedesjegyig, és kiszámoltam az összeget és az eredeti érték és a kerekített érték közötti különbséget.
Í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 csonkolás utáni különbség 499.9016193868665, kerektől pedig 0.04661938686695066
A különbség nagyon nagynak tűnik, és a példa bemutatja, hogyan segít a kerekítés() módszer a közeli pontosság kiszámításában.
Példa: Kerekítő úszó Numbers
Ebben a programban látni fogjuk, hogyan kerekítik a szavakat 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
Lássunk 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 Arrays
Hogyan kerekítsünk zsibbadt tömbök pythonban?
Ennek megoldására használhatjuk a numpy modult és a numpy.round() vagy numpy.around() metódust, ahogy az alábbi példában is 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()-ot is, amely ugyanazt az eredményt adja, mint az alábbi példában.
Példa: Decimális modul
A round() függvényen kívül a pythonnak van egy decimális modulja is, amely segít a decimális számok pontosabb kezelésében.
A decimális modul kerekítési típusokkal rendelkezik, az alábbiak szerint:
- ROUND_CEILING: a végtelen felé kerekedik,
- ROUND_DOWN: az értéket nulla felé kerekíti,
- ROUND_FLOOR: a végtelen felé kerekedik,
- ROUND_HALF_DOWN: a legközelebbi értékre kerekít, a nulla felé haladva,
- ROUND_HALF_EVEN: a legközelebbire kerekít, és az értéke a legközelebbi páros egész számra megy,
- ROUND_HALF_UP: a legközelebbire kerekít, az érték nullától eltér
- ROUND_UP: ott kerekít, ahol az érték elmegy 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
Összegzésként
- A Round(float_num, Num_of_decimals) a pythonhoz elérhető beépített függvény. Visszaadja a lebegőpontos számot, amelyet a bemenetként megadott tizedesjegyekre kerekít.
- float_num: a kerekítendő float szám.
- Num_of_decimals: A kerekítés során figyelembe veendő tizedesjegyek száma.
- Egész értéket ad vissza, ha a tizedesek_száma nincs megadva, és lebegő értéket, ha a tizedesek_száma adott.
