Python funcția round() cu EXEMPLE

Rundă()

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

• float_num: numărul float care trebuie rotunjit.
• num_of_decimals: (opțional) Numărul de zecimale care trebuie luate în considerare la rotunjire. Este opțional, iar dacă nu este specificat, este implicit 0, iar rotunjirea se face la cel mai apropiat număr întreg.

Descriere

Metoda round() are două argumente

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

Al doilea argument este opțional și este implicit la 0 atunci când nu este specificat și, în acest 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 după zecimală este dat

• >=5 decât + 1 va fi adăugat la valoarea finală
• <5 decât valoarea finală va reveni, deoarece este până la zecimalele menționate.

Valoare returnată

Va returna o valoare întreagă dacă nu este dat num_of_decimals și o valoare float dacă este dat num_of_decimals. Vă rugăm să rețineți că valoarea va fi rotunjită la +1 dacă valoarea după virgulă este >=5, altfel va returna valoarea, deoarece este până la zecimalele menționate.

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

Cel mai bun exemplu pentru a arăta impactul rotunjirii este pentru 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 pentru fiecare tranzacție.

S-a făcut de aproape 3000 de ori în fiecare zi. Trunchiările acumulate duc 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 de stoc. Momentan îl generez pentru o serie 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 o mică bucată de cod în care la început, trebuie să utilizați numerele până la doar 3 zecimale, adică trunchierea numărului după 3 zecimale.

Am valoarea totală inițială, totalul provenind din valori trunchiate și diferența dintre valoarea originală ș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 original și după trunchiere este 499.9016193868665, iar de la rotund, este 0.04661938686695066

Diferența pare să fie foarte mare, iar exemplul arată cum metoda rotunjire() ajută la calcularea aproape de precizie.

Exemplu: rotunjire flotantă Numbers

În acest program, vom vedea cum se rotunjesc cuvintele pe numere plutitoare

# 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 pe numerele 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: Round Numpy Arrays

Cum să rotunjiți numpy matrice în python?

Pentru a rezolva acest lucru, putem folosi modulul numpy și folosim 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]

De asemenea, putem folosi numpy.around(), care vă oferă același rezultat ca în exemplul de mai jos.

Exemplu: Modulul Decimal

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

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

• ROUND_CEILING: se va rotunji spre Infinit,
• ROUND_DOWN: va rotunji valoarea spre zero,
• ROUND_FLOOR: se va rotunji spre -Infinit,
• ROUND_HALF_DOWN: se va rotunji la cea mai apropiată valoare mergând spre zero,
• ROUND_HALF_EVEN: se va rotunji la cel mai apropiat, cu valoarea la cel mai apropiat număr întreg par,
• ROUND_HALF_UP: se va rotunji la cea mai apropiată, cu valoarea plecând de la zero
• ROUND_UP: se va rotunji 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

Rezumat

• Round(float_num, Num_of_decimals) este o funcție încorporată disponibilă cu python. Vă va returna numărul flotant care va fi rotunjit la zecimale care sunt date ca intrare.
• float_num: numărul float care trebuie rotunjit.
• Număr_de_zecimale: este numărul de zecimale care trebuie luate în considerare la rotunjire.
• Va returna o valoare întreagă dacă nu este dat num_of_decimals și o valoare float dacă este dat num_of_decimals.