Python उदाहरण के साथ round() फ़ंक्शन

गोल()

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

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

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

round(float_num, num_of_decimals)

पैरामीटर्स

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

विवरण

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

  • पूर्णांकित की जाने वाली संख्या और
  • दशमलव स्थान जिन्हें पूर्णांक बनाते समय ध्यान में रखना चाहिए।

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

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

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

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

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

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

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

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

ऐसा प्रतिदिन लगभग 3000 बार किया जाता था। संचित कटौती के कारण प्रति माह लगभग 25 अंकों का नुकसान होता है।

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

नीचे दिए गए फ्लोटिंग-पॉइंट नंबरों को स्टॉक वैल्यू के रूप में मान लें। अभी मैं इसे कई रेंज के लिए जेनरेट कर रहा हूँ

1,000,000 और 0.01 के बीच 0.05 सेकंड.

उदाहरण:

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 मॉड्यूल का उपयोग कर सकते हैं और 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() का भी उपयोग कर सकते हैं, जो आपको नीचे दिए गए उदाहरण के समान परिणाम देता है।

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

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

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

  • ROUND_CEILING: यह अनंत की ओर घूमेगा,
  • ROUND_DOWN: यह मान को शून्य की ओर पूर्णांकित कर देगा,
  • ROUND_FLOOR: यह -अनंत की ओर गोल होगा,
  • ROUND_HALF_DOWN: यह शून्य की ओर जाते हुए निकटतम मान तक पूर्णांकित होगा,
  • ROUND_HALF_EVEN: यह निकटतम सम पूर्णांक तक मान के साथ निकटतम पूर्णांक तक जाएगा,
  • ROUND_HALF_UP: यह शून्य से दूर जाते हुए मान को निकटतम तक पूर्णांकित करेगा
  • ROUND_UP: यह उस स्थान पर पूर्णांकित करेगा जहां मान शून्य से दूर जाएगा।

दशमलव में, 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

सारांश

  • Round(float_num, Num_of_decimals) पाइथन के साथ उपलब्ध एक अंतर्निहित फ़ंक्शन है। यह आपको फ़्लोट संख्या लौटाएगा जिसे इनपुट के रूप में दिए गए दशमलव स्थानों तक राउंड किया जाएगा।
  • float_num: पूर्णांकित की जाने वाली फ्लोट संख्या.
  • Num_of_decimals: यह दशमलवों की वह संख्या है जिसे पूर्णांक बनाते समय ध्यान में रखा जाता है।
  • यदि num_of_decimals नहीं दिया गया है तो यह एक पूर्णांक मान लौटाएगा और यदि num_of_decimals दिया गया है तो यह एक फ़्लोट मान लौटाएगा।