Python round() z PRZYKŁADAMI

Okrągły()

Round() to wbudowana funkcja dostępna w Pythonie. Zwróci ci liczbę zmiennoprzecinkową, która zostanie zaokrąglona do miejsc dziesiętnych podanych jako dane wejściowe.

Jeżeli nie określono liczby miejsc dziesiętnych, które mają zostać zaokrąglone, uznaje się je za 0 i zaokrągla się do najbliższej liczby całkowitej.

Składnia

round(float_num, num_of_decimals)

parametry

• float_num: liczba zmiennoprzecinkowa, która ma zostać zaokrąglona.
• num_of_decimals: (opcjonalne) Liczba miejsc dziesiętnych, które należy uwzględnić podczas zaokrąglania. Jest to opcjonalne i jeśli nie jest określone, domyślnie przyjmuje wartość 0, a zaokrąglanie jest wykonywane do najbliższej liczby całkowitej.

Opis

Metoda round() przyjmuje dwa argumenty

• liczba, która ma zostać zaokrąglona i
• miejsca po przecinku, które należy wziąć pod uwagę podczas zaokrąglania.

Drugi argument jest opcjonalny i domyślnie wynosi 0, jeśli nie jest określony; w takim przypadku zostanie zaokrąglony do najbliższej liczby całkowitej, a typem zwracanym będzie również liczba całkowita.

Jeśli wystąpią miejsca dziesiętne, czyli drugi argument, nastąpi zaokrąglenie do liczby podanych miejsc. Typ zwracany będzie typu float.

Jeżeli podana jest liczba po przecinku

• >=5 niż + 1 zostanie dodane do wartości końcowej
• <5 niż ostateczna wartość zostanie zwrócona, ponieważ zależy od podanych miejsc po przecinku.

Wartość zwracana

Zwróci wartość całkowitą, jeśli nie podano liczby_dziesiętnych, i wartość zmiennoprzecinkową, jeśli podano liczbę_dziesiętnych. Należy pamiętać, że wartość zostanie zaokrąglona do +1, jeśli wartość po przecinku wynosi >=5, w przeciwnym razie zwrócona zostanie wartość z dokładnością do podanych miejsc dziesiętnych.

Jak duży wpływ może mieć zaokrąglanie? (Zaokrąglenie a obcięcie)

Najlepszym przykładem pokazującym wpływ zaokrągleń jest rynek giełdowy. W przeszłości tj. w 1982 r Giełda w Vancouver (VSE): używany do obcinania wartości akcji do trzech miejsc po przecinku w każdej transakcji.

Robiono to prawie 3000 razy każdego dnia. Nagromadzone obcięcia prowadzą do utraty około 25 punktów miesięcznie.

Poniżej pokazano przykład obcięcia wartości w porównaniu z zaokrągleniem.

Rozważ liczby zmiennoprzecinkowe wygenerowane poniżej jako wartości giełdowe. W tej chwili generuję je dla zakresu

1,000,000 0.01 0.05 sekund między XNUMX a XNUMX.

Przykłady:

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

Aby pokazać wpływ zaokrąglania, napisałem krótki fragment kodu, w którym na początku należy używać liczb z dokładnością do 3 miejsc po przecinku, tzn. liczba jest obcinana po 3 miejscach po przecinku.

Mam oryginalną wartość całkowitą, sumę pochodzącą z wartości obciętych i różnicę między wartością pierwotną i obciętą.

Do tego samego zestawu liczb używałem metody round() z dokładnością do trzech miejsc po przecinku i obliczałem sumę oraz różnicę między wartością oryginalną a wartością zaokrągloną.

Oto przykład i wynik
1 przykład

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)

Wyjście:

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

Różnica między oryginałem a po obcięciu wynosi 499.9016193868665, a od zaokrąglenia 0.04661938686695066

Różnica wydaje się być bardzo duża, a przykład pokazuje, jak metoda round() pomaga w obliczeniach z dużą dokładnością.

Przykład: Zaokrąglanie float Numbers

W tym programie pokażemy, jak zaokrąglać słowa w liczbach zmiennoprzecinkowych

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

Wyjście:

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

Przykład: Zaokrąglanie wartości całkowitych

Jeśli zdarzy ci się użyć funkcji round() na wartości całkowitej, zwróci ona liczbę bez żadnych zmian.

# testing round() on a integer

num = 15

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

Wyjście:

The output is 15

Przykład: Zaokrąglanie na minusie Numbers

Zobaczmy kilka przykładów, jak działa zaokrąglanie liczb ujemnych

# testing round()

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

Wyjście:

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

Przykład: okrągłe tablice Numpy

Jak zaokrąglić numpy tablice w Pythonie?

Aby rozwiązać ten problem, możemy skorzystać z modułu numpy i użyć metody numpy.round() lub numpy.around(), jak pokazano w przykładzie poniżej.

Używanie 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)

Wyjście:

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

Możemy także użyć metody numpy.around(), która daje taki sam wynik, jak pokazano w przykładzie poniżej.

Przykład: moduł dziesiętny

Oprócz funkcji round() Python posiada moduł decimal, który pozwala na dokładniejszą obsługę liczb dziesiętnych.

Moduł Decimal zawiera typy zaokrągleń, jak pokazano poniżej:

• ROUND_CEILING: będzie zaokrąglał w stronę Nieskończoności,
• ROUND_DOWN: zaokrągli wartość do zera,
• ROUND_FLOOR: zaokrągli się w kierunku -Infinity,
• ROUND_HALF_DOWN: zaokrągli do najbliższej wartości zmierzającej w kierunku zera,
• ROUND_HALF_EVEN: zaokrągli do najbliższej liczby całkowitej, przy czym wartość będzie zaokrąglana do najbliższej liczby parzystej,
• ROUND_HALF_UP: zaokrągli do najbliższej wartości, oddalając ją od zera
• ROUND_UP: zaokrągli miejsce, w którym wartość będzie odbiegać od zera.

W przypadku systemu dziesiętnego metoda quantize() pomaga zaokrąglić do ustalonej liczby miejsc po przecinku i można określić sposób zaokrąglania, jak pokazano w przykładzie poniżej.
Przykład:
Używanie metod round() i dziesiętnych

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)

Wyjście:

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

Podsumowanie

• Round(float_num, Num_of_decimals) to wbudowana funkcja dostępna w Pythonie. Zwróci ci liczbę zmiennoprzecinkową, która zostanie zaokrąglona do miejsc dziesiętnych podanych jako dane wejściowe.
• float_num: liczba zmiennoprzecinkowa, która ma zostać zaokrąglona.
• Num_of_decimals: Jest to liczba miejsc po przecinku, które należy wziąć pod uwagę podczas zaokrąglania.
• Zwróci wartość całkowitą, jeśli nie podano liczby_dziesiętnych, i wartość zmiennoprzecinkową, jeśli podano liczbę_dziesiętnych.