Python round () függvény a PÉLDÁK segítségével

Tartalomjegyzék:

Anonim

Kerek()

A Round () egy beépített függvény, amely Python-nal érhető el. Visszaad egy úszó számot, amelyet a bemenetként megadott tizedesjegyekre kerekítünk.

Ha a kerekítendő tizedesjegyeket nem adják meg, akkor 0-nak tekintjük, és a legközelebbi egész számra kerekít.

Ebben a Python oktatóanyagban megtudhatja:

  • Kerek()
  • Szintaxis:
  • Mennyi hatása lehet a kerekítésnek? (Kerekítés és csonkolás)
  • Példa: Úszó számok kerekítése
  • Példa: Egész számok kerekítése
  • Példa: A negatív számok kerekítése
  • Példa: Kerek Numpy tömbök
  • Példa: Tizedes modul

Szintaxis:

round(float_num, num_of_decimals)

Paraméterek

  • float_num: a kerekítendő úszószám.
  • tizedesjegyek száma: (választható) A kerekítés során figyelembe veendő tizedesjegyek száma. Opcionális, é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ám és
  • a tizedesjegyek, amelyeket a kerekítés során figyelembe kell vennie.

A második argumentum opcionális, é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és típusa is egész szám lesz.

Ha a tizedesjegyek, azaz a második argumentum jelen van, akkor az a megadott helyek számára kerekít. A visszatérési típus úszó 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, visszatér az említett tizedesjegyekig.

Visszatérési érték

Egész számértéket ad vissza, ha nem adjuk meg a tizedesjegyek számát, és lebegő értéket, ha a tizedesek számát megadjuk. Kérjük, vegye figyelembe, hogy az értéket +1-re kerekítjük, ha a tizedesjegy utáni érték> = 5, ellenkező esetben az értéket az említett tizedesjegyekig eléri.

Mennyi hatása lehet a kerekítésnek? (Kerekítés és csonkolás)

A kerekítés hatásának bemutatására a legjobb példa a tőzsde piaca. A múltban, azaz 1982-ben, a Vancouveri Értéktőzsde (VSE): a részvényértékeket három tizedesjegyig csonkította minden kereskedésnél.

Naponta csaknem 3000-szer végezték el. A felhalmozott csonkítások havi 25 pont körüli veszteséghez vezetnek.

Az alábbiakban bemutatunk egy példát az értékek csonkítására a kerekítéssel szemben.

Tekintsük az alább generált lebegőpontos számokat készletértékként. Jelenleg egy sorra generálom

1 000 000 másodperc 0,01 és 0,05 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ához írtam egy kis kóddarabot, amelyben először csak 3 tizedesjegyig kell használni a számokat, azaz 3 tizedesjegy után meg kell csonkítani a számot.

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

Ugyanazon a számsorozaton kerek () módszert használtam három tizedesjegyig, és kiszámítottam az összeget, valamint az eredeti és a kerekített érték közötti különbséget.

Itt van a példa és a kimenet

1. példa

import randomdef truncate(num):return int(num * 1000) / 1000arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]sum_num = 0sum_truncate = 0for i in arr:sum_num = sum_num + isum_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 = 0sum_truncate1 = 0for i in arr:sum_num1 = sum_num1 + isum_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)

Kimenet:

Testing by using truncating upto 3 decimal placesThe original sum is = 29985.958619386867The total using truncate = 29486.057The difference from original - truncate = 499.9016193868665Testing by using round() up to 3 decimal placesThe original sum is = 29985.958619386867The total using round = 29985.912The difference from original - round = 0.04661938686695066

Az eredeti és a csonkolás utáni különbség 499,9016193868665, kerekből pedig 0,04661938686695066

Úgy tűnik, hogy a különbség nagyon nagy, és a példa megmutatja, hogy a kerekítés () módszer hogyan segít a pontossághoz közeli számításban.

Példa: Úszó számok kerekítése

Ebben a programban meglátjuk, hogyan kerekítik a szavakat a 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 >5float_num2 = 10.40 # here the value will be rounded to 10 as after the decimal point the number is 4 that is <=5float_num3 = 10.3456 # here the value will be 10.35 as after the 2 decimal points the value >=5float_num4 = 10.3445 #here the value will be 10.34 as after the 2 decimal points the value is <5print("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))

Kimenet:

The rounded value without num_of_decimals is : 11The rounded value without num_of_decimals is : 10The rounded value with num_of_decimals as 2 is : 10.35The rounded value with num_of_decimals as 2 is : 10.34

Példa: Egész számok kerekítése

Ha véletlenül a round () értéket használja egy egész értékre, akkor az csak vissza fogja adni a számot változtatások nélkül.

# testing round() on a integernum = 15print("The output is", round(num))

Kimenet:

The output is 15

Példa: A negatív számok kerekítése

Lássunk néhány példát arra, hogy a kerekítés hogyan működik negatív számokon

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

Kimenet:

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

Példa: Kerek Numpy tömbök

Hogyan kerekítsük a numerikus tömböket a pythonban?

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

A numpy.round () használata

# testing round()import numpy as nparr = [-0.341111, 1.455098989, 4.232323, -0.3432326, 7.626632, 5.122323]arr1 = np.round(arr, 2)print(arr1)

Kimenet:

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

Használhatjuk a numpy.around () -t is, amely ugyanazt az eredményt adja, mint az alábbi példában látható.

Példa: Tizedes modul

A round () függvény mellett a python rendelkezik egy decimális modullal, amely segít a tizedes számok pontos kezelésében.

A Decimal modul kerekítési típusokkal rendelkezik, az alábbiak szerint:

  • FUTÓ: a Végtelen felé fog kerekíteni,
  • ROUND_DOWN: nullára kerekíti az értéket,
  • ROUND_FLOOR: a végtelenség felé fog kerekíteni,
  • ROUND_HALF_DOWN: a legközelebbi nullára kerülő értékre kerekít,
  • ROUND_HALF_EVEN: a legközelebbi értékre kerekszik, amelynek értéke a legközelebbi egész számra megy,
  • ROUND_HALF_UP: a legközelebbi értékre kerekszik, amelynek értéke nullától távolabbra kerül
  • ROUND_UP: ott kerekít, ahol az érték nulláról elmúlik.

Tizedesjegyekben a quantize () módszer segít lekerekíteni egy fix tizedesjegyig, és megadhatja az alkalmazandó kerekítést, amint az az alábbi példában látható.

Példa:

Kerek () és decimális módszerekkel

import decimalround_num = 15.456final_val = round(round_num, 2)#Using decimal modulefinal_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)

Kimenet:

Using round() 15.46Using Decimal - ROUND_CEILING 15.46Using Decimal - ROUND_DOWN 15.45Using Decimal - ROUND_FLOOR 15.45Using Decimal - ROUND_HALF_DOWN 15.46Using Decimal - ROUND_HALF_EVEN 15.46Using Decimal - ROUND_HALF_UP 15.46Using Decimal - ROUND_UP 15.46

Összegzés:

  • A Round (float_num, Num_of_decimals) egy beépített függvény, amely Python-nal érhető el. Visszaadja az úszószámot, amelyet a bemenetként megadott tizedesjegyekre kerekítünk.
  • float_num: a kerekítendő úszószám.
  • Tizedesjegyek száma: A kerekítés során figyelembe veendő tizedesjegyek száma.
  • Egész számértéket ad vissza, ha nem adjuk meg a tizedesjegyek számát, és lebegő értéket, ha a tizedesek számát megadjuk.