Python round() फ़ंक्शन का उदाहरणों सहित उपयोग

round() फ़ंक्शन क्या है? Python?

Python round() एक अंतर्निर्मित फ़ंक्शन है जो इसके साथ उपलब्ध है Pythonयह आपको एक फ्लोट संख्या लौटाएगा जिसे इनपुट के रूप में दिए गए दशमलव स्थानों तक पूर्णांकित किया जाएगा।

यदि पूर्णांकित किए जाने वाले दशमलव स्थान निर्दिष्ट नहीं किए गए हैं, तो इसे 0 माना जाएगा, तथा इसे निकटतम पूर्णांक तक पूर्णांकित किया जाएगा।

वाक्य - विन्यास

round(float_num, num_of_decimals)

पैरामीटर्स

• फ्लोट_नंबर: राउंड ऑफ की जाने वाली फ्लोट संख्या।
• दशमलव की संख्या: (वैकल्पिक) राउंडिंग करते समय विचार किए जाने वाले दशमलव स्थानों की संख्या। यह वैकल्पिक है, और यदि निर्दिष्ट नहीं किया जाता है, तो यह डिफ़ॉल्ट रूप से 0 होता है, और राउंडिंग निकटतम पूर्णांक तक की जाती है।

विवरण

round() विधि दो तर्क लेती है:

• जिस संख्या को राउंड ऑफ करना है, और
• दशमलव स्थान जिन्हें पूर्णांक बनाते समय ध्यान में रखना चाहिए।

दूसरा तर्क वैकल्पिक है और निर्दिष्ट न होने पर डिफ़ॉल्ट रूप से 0 होता है, और ऐसे मामले में, यह निकटतम पूर्णांक तक राउंड करेगा, और रिटर्न प्रकार भी एक पूर्णांक होगा।

जब दशमलव स्थान, यानी दूसरा तर्क, मौजूद होता है, तो यह दिए गए स्थानों की संख्या तक पूर्णांकित हो जाएगा। रिटर्न प्रकार फ़्लोट होगा।

यदि दिए गए दशमलव स्थान के बाद की संख्या यह है:

• यदि मान >= 5 है, तो अंतिम मान में +1 जोड़ा जाएगा।
• यदि मान < 5 है, तो अंतिम मान उल्लिखित दशमलव स्थानों तक यथावत लौटाया जाएगा।

प्रतिलाभ की मात्रा

यदि दशमलव की संख्या नहीं दी गई है तो यह पूर्णांक मान लौटाएगा, और यदि संख्या दी गई है तो यह फ्लोट मान लौटाएगा। कृपया ध्यान दें कि यदि दशमलव बिंदु के बाद का मान 5 या उससे अधिक है, तो मान को +1 तक पूर्णांकित किया जाएगा, अन्यथा यह मान को बताए गए दशमलव स्थानों तक यथावत लौटाएगा।

राउंडिंग का कितना प्रभाव हो सकता है? (राउंडिंग बनाम ट्रंकेशन)

राउंडिंग के प्रभाव को दर्शाने का सबसे अच्छा उदाहरण स्टॉक एक्सचेंज बाजार है। अतीत में, यानी वर्ष 1982 में, वैंकूवर स्टॉक एक्सचेंज (VSE) प्रत्येक ट्रेड पर स्टॉक मूल्यों को तीन दशमलव स्थानों तक सीमित करने के लिए उपयोग किया जाता था।

यह प्रक्रिया प्रतिदिन लगभग 3000 बार दोहराई जाती थी। इसके परिणामस्वरूप हर महीने लगभग 25 अंकों का नुकसान होता था।

मानों को छोटा करने बनाम पूर्णांक बनाने का एक उदाहरण नीचे दिखाया गया है।

नीचे जनरेट किए गए फ्लोटिंग-पॉइंट नंबरों को स्टॉक वैल्यू मानिए। अभी मैं इन्हें 0.01 और 0.05 के बीच 1,000,000 सेकंड की रेंज के लिए जनरेट कर रहा हूं।

उदाहरण:

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

राउंडिंग के प्रभाव को दिखाने के लिए, मैंने कोड का एक छोटा सा हिस्सा लिखा है जिसमें, पहले, आप केवल 3 दशमलव स्थानों तक की संख्याओं का उपयोग करते हैं, यानी 3 दशमलव स्थानों के बाद संख्या को हटा देते हैं।

मेरे पास मूल कुल मूल्य, ट्रंकेटेड मूल्यों से प्राप्त कुल मूल्य और मूल तथा ट्रंकेटेड मूल्य के बीच का अंतर है।

संख्याओं के उसी समूह पर, मैंने 3 दशमलव स्थानों तक round() विधि का उपयोग किया है और मूल मान और राउंडेड मान के बीच योग और अंतर की गणना की है।

यहां उदाहरण और आउटपुट दिया गया है।

उदाहरण 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)

आउटपुट:

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

मूल और ट्रंकेटेड मान के बीच का अंतर 499.9016193868665 है, और राउंड() से यह 0.04661938686695066 है।

अंतर काफी बड़ा प्रतीत होता है, और उदाहरण से पता चलता है कि round() विधि सटीकता के करीब गणना करने में कैसे मदद करती है।

उदाहरण: राउंडिंग फ्लोट Numbers

इस प्रोग्राम में हम देखेंगे कि फ्लोटिंग संख्याओं पर राउंडिंग कैसे काम करती है।

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

आउटपुट:

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

उदाहरण: पूर्णांक मानों को पूर्णांकित करना

यदि आप पूर्णांक मान पर round() का उपयोग करते हैं, तो यह बिना किसी परिवर्तन के आपको संख्या वापस लौटा देगा।

# testing round() on a integer

num = 15

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

आउटपुट:

The output is 15

उदाहरण: ऋणात्मक पर पूर्णांकन Numbers

आइए कुछ उदाहरण देखें कि ऋणात्मक संख्याओं पर राउंडिंग कैसे काम करती है।

# testing round()

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

आउटपुट:

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

उदाहरण: NumPy सरणियों को गोल करना

आप NumPy में राउंडिंग कैसे करते हैं? सरणियों में Python?

इस समस्या को हल करने के लिए, हम NumPy मॉड्यूल का उपयोग कर सकते हैं और numpy.round() या numpy.around() विधि का उपयोग कर सकते हैं, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है।

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)

आउटपुट:

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

हम numpy.around() का भी उपयोग कर सकते हैं, जो आपको ऊपर दिखाए गए numpy.round() के समान परिणाम देता है।

उदाहरण: दशमलव मॉड्यूल

round() फ़ंक्शन के अलावा, Python इसमें एक दशमलव मॉड्यूल है जो दशमलव संख्याओं को अधिक सटीकता से संभालने में मदद करता है।

डेसिमल मॉड्यूल में राउंडिंग प्रकार शामिल हैं, जैसा कि नीचे दिखाया गया है:

• गोल छत: यह अनंत की ओर मंडराएगा।
• राउंड_डाउन: यह मान को शून्य की ओर पूर्णांकित कर देगा।
• गोल तल: यह अनंत की ओर गोल घूमेगा।
• राउंड_हाफ_डाउन: यह शून्य की ओर बढ़ते हुए निकटतम मान तक पूर्णांकित हो जाएगा।
• राउंड_हाफ_इवन: यह निकटतम सम पूर्णांक तक पहुंचने के लिए राउंड ऑफ हो जाएगा।
• राउंड_हाफ_अप: यह शून्य से दूर जाते हुए निकटतम मान तक पूर्णांकित हो जाएगा।
• बढ़ाना: यह उस बिंदु पर राउंड करेगा जहां मान शून्य से दूर चला जाएगा।

दशमलव में, quantize() विधि दशमलव स्थानों की एक निश्चित संख्या तक पूर्णांक बनाने में मदद करती है, और आप उपयोग की जाने वाली पूर्णांकन को निर्दिष्ट कर सकते हैं, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है।

उदाहरण: round() और दशमलव विधियों का उपयोग करना

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)

आउटपुट:

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

अक्सर पूछे जाने वाले प्रश्न