पायथन राउंड () समारोह के साथ समारोह

विषय - सूची:

Anonim

गोल()

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

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

इस पायथन ट्यूटोरियल में, आप सीखेंगे:

  • गोल()
  • वाक्य - विन्यास:
  • गोलाई का कितना असर हो सकता है? (ट्रंकेशन बनाम राउंडिंग)
  • उदाहरण: फ्लोट नंबरों को गोल करना
  • उदाहरण: पूर्णांक पूर्णांक मान
  • उदाहरण: ऋणात्मक संख्याओं पर गोलाई
  • उदाहरण: गोल Numpy Arrays
  • उदाहरण: दशमलव मॉड्यूल

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

round(float_num, num_of_decimals)

मापदंडों

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

विवरण

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

  • गोल करने की संख्या और
  • गोलाई वाले स्थानों को गोलाई लेते समय विचार करना चाहिए।

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

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

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

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

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

यदि num_of_decimals नहीं दिया गया है और num_of_decimals दिया गया है तो एक फ्लोट वैल्यू होने पर यह एक पूर्णांक मान लौटाएगा। कृपया ध्यान दें कि यदि दशमलव बिंदु> = 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 दशमलव स्थानों तक राउंड () पद्धति का उपयोग कर रहा हूं और योग और मूल मूल्य और गोल मूल्य के बीच अंतर की गणना कर रहा हूं।

यहाँ उदाहरण और आउटपुट हैं

उदाहरण 1

import randomdef truncate(num):return int(num * 1000) / 1000arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]sum_num = 0sum_truncate = 0for i in arr:sum_num = sum_num + isum_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 = 0sum_truncate1 = 0for i in arr:sum_num1 = sum_num1 + isum_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 placesThe original sum is = 29985.958619386867The total using truncate = 29486.057The difference from original - truncate = 499.9016193868665Testing by using round() up to 3 decimal placesThe original sum is = 29985.958619386867The total using round = 29985.912The difference from original - round = 0.04661938686695066

मूल और ट्रंक करने के बाद का अंतर 499.9016193868665 है, और दौर से, यह 0.04661938686695066 है

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

उदाहरण: फ्लोट नंबरों को गोल करना

इस कार्यक्रम में, हम देखेंगे कि फ्लोटिंग नंबरों पर शब्द कैसे घूमते हैं

# 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 >5float_num2 = 10.40 # here the value will be rounded to 10 as after the decimal point the number is 4 that is <=5float_num3 = 10.3456 # here the value will be 10.35 as after the 2 decimal points the value >=5float_num4 = 10.3445 #here the value will be 10.34 as after the 2 decimal points the value is <5print("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 : 11The rounded value without num_of_decimals is : 10The rounded value with num_of_decimals as 2 is : 10.35The rounded value with num_of_decimals as 2 is : 10.34

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

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

# testing round() on a integernum = 15print("The output is", round(num))

आउटपुट:

The output is 15

उदाहरण: ऋणात्मक संख्याओं पर गोलाई

आइए देखते हैं कि नकारात्मक संख्याओं पर गोलाई कैसे काम करती है

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

आउटपुट:

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

उदाहरण: गोल Numpy Arrays

अजगर में सुन्न सरणियों को गोल कैसे करें?

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

Numpy.round का उपयोग करना ()

# testing round()import numpy as nparr = [-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.ेशन () का भी उपयोग कर सकते हैं, जो आपको नीचे दिए गए उदाहरण में दिखाए गए परिणाम के समान है।

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

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

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

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

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

उदाहरण:

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

import decimalround_num = 15.456final_val = round(round_num, 2)#Using decimal modulefinal_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.46Using Decimal - ROUND_CEILING 15.46Using Decimal - ROUND_DOWN 15.45Using Decimal - ROUND_FLOOR 15.45Using Decimal - ROUND_HALF_DOWN 15.46Using Decimal - ROUND_HALF_EVEN 15.46Using Decimal - ROUND_HALF_UP 15.46Using Decimal - ROUND_UP 15.46

सारांश:

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