Python Funcția round() cu EXEMPLE

Ce este funcția round() în Python?

Python round() este o funcție încorporată disponibilă cu Python. Vă va returna un număr flotant care va fi rotunjit la zecimale care sunt date ca intrare.

Dacă zecimalele care trebuie rotunjite nu sunt specificate, aceasta este considerată 0 și se va rotunji la cel mai apropiat număr întreg.

Sintaxă

round(float_num, num_of_decimals)

parametrii

• număr_float: Numărul cu virgulă mobilă care va fi rotunjit.
• număr_de_zecimale: (opțional) Numărul de zecimale care vor fi luate în considerare la rotunjire. Este opțional și, dacă nu este specificat, valoarea implicită este 0, iar rotunjirea se face la cel mai apropiat număr întreg.

Descriere

Metoda round() primește două argumente:

• numărul care trebuie rotunjit și
• zecimale pe care ar trebui să le ia în considerare la rotunjire.

Al doilea argument este opțional și implicit are valoarea 0 atunci când nu este specificat, iar într-un astfel de caz, se va rotunji la cel mai apropiat număr întreg, iar tipul returnat va fi, de asemenea, un număr întreg.

Când zecimalele, adică al doilea argument, sunt prezente, se va rotunji la numărul de locuri dat. Tipul de returnare va fi un float.

Dacă numărul de după zecimală dat este:

• >= 5, atunci + 1 va fi adăugat la valoarea finală.
• < 5, atunci valoarea finală va fi returnată așa cum este, până la zecimalele menționate.

Valoare returnată

Va returna o valoare întreagă dacă nu este specificat num_of_decimals și o valoare float dacă este specificat num_of_decimals. Rețineți că valoarea va fi rotunjită la +1 dacă valoarea de după virgulă este >= 5, altfel va returna valoarea așa cum este, până la zecimalele menționate.

Cât impact poate avea rotunjirea? (Rotunjire vs trunchiere)

Cel mai bun exemplu pentru a ilustra impactul rotunjirii este piața bursieră. În trecut, adică în anul 1982, Bursa de Valori din Vancouver (VSE) folosit pentru a trunchia valorile acțiunilor la trei zecimale la fiecare tranzacție.

Se făcea de aproape 3000 de ori pe zi. Trunchierile acumulate au dus la o pierdere de aproximativ 25 de puncte pe lună.

Un exemplu de trunchiere a valorilor versus rotunjire este prezentat mai jos.

Luați în considerare numerele în virgulă mobilă generate mai jos ca valori bursiere. În acest moment, le generez pentru un interval de 1,000,000 de secunde între 0.01 și 0.05.

Exemple:

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

Pentru a arăta impactul rotunjirii, am scris un mic fragment de cod în care, la început, folosești numerele cu până la 3 zecimale, adică trunchiezi numărul după 3 zecimale.

Am valoarea totală inițială, totalul provenit din valorile trunchiate și diferența dintre valoarea inițială și cea trunchiată.

Pe același set de numere, am folosit metoda round() cu până la 3 zecimale și am calculat suma și diferența dintre valoarea inițială și valoarea rotunjită.

Iată exemplul și rezultatul.

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

ieșire:

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

Diferența dintre valoarea originală și cea trunchiată este 499.9016193868665, iar din round() este 0.04661938686695066.

Diferența pare a fi foarte mare, iar exemplul arată cum metoda round() ajută la calcularea cu o precizie apropiată.

Exemplu: rotunjire flotantă Numbers

În acest program, vom vedea cum funcționează rotunjirea numerelor flotante.

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

ieșire:

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

Exemplu: rotunjirea valorilor întregi

Dacă se întâmplă să utilizați round() pe o valoare întreagă, acesta vă va returna numărul înapoi fără nicio modificare.

# testing round() on a integer

num = 15

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

ieșire:

The output is 15

Exemplu: rotunjire pe negativ Numbers

Să vedem câteva exemple despre cum funcționează rotunjirea numerelor negative.

# testing round()

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

ieșire:

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

Exemplu: Rotunjirea matricelor NumPy

Cum rotunjești NumPy? matrice în Python?

Pentru a rezolva această problemă, putem folosi modulul NumPy și metoda numpy.round() sau numpy.around(), așa cum se arată în exemplul de mai jos.

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

ieșire:

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

Putem folosi și numpy.around(), care oferă același rezultat ca și numpy.round() prezentat mai sus.

Exemplu: Modulul Decimal

Pe lângă funcția round(), Python are un modul zecimal care ajută la gestionarea mai precisă a numerelor zecimale.

Modulul Decimal vine cu tipuri de rotunjire, așa cum se arată mai jos:

• ROUND_CEILING: se va rotunji spre Infinit.
• ROTUNJIRE_ÎN_DOWN: va rotunji valoarea spre zero.
• ROUND_FLOOR: se va rotunji spre -Infinit.
• ROUND_HALF_DOWN: se va rotunji la cea mai apropiată valoare care se apropie de zero.
• ROUND_HALF_EVEN: se va rotunji la cea mai apropiată valoare mergând spre cel mai apropiat număr întreg par.
• ROUND_HALF_UP: se va rotunji la cea mai apropiată valoare care se îndepărtează de zero.
• RIDICA: se va rotunji acolo unde valoarea se va îndepărta de zero.

În zecimală, metoda quantize() ajută la rotunjirea la un număr fix de zecimale și puteți specifica rotunjirea care trebuie utilizată, așa cum se arată în exemplul de mai jos.

Exemplu: Folosind metode round() și zecimale

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)

ieșire:

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

Întrebări frecvente