पायथन संख्या, प्रकार रूपांतरण और गणित

इस लेख में, आप पायथन में उपयोग किए जाने वाले विभिन्न नंबरों के बारे में जानेंगे, एक डेटा प्रकार से दूसरे में कैसे परिवर्तित करें, और पायथन में समर्थित गणितीय संचालन।

पायथन में संख्या डेटा प्रकार

पायथन पूर्णांक, फ्लोटिंग-पॉइंट संख्या और जटिल संख्याओं का समर्थन करता है। वे के रूप में परिभाषित कर रहे हैं int, floatऔर complexअजगर में कक्षाएं।

पूर्णांक और फ़्लोटिंग पॉइंट दशमलव बिंदु की उपस्थिति या अनुपस्थिति से अलग होते हैं। उदाहरण के लिए, 5 एक पूर्णांक है जबकि 5.0 एक फ्लोटिंग-पॉइंट संख्या है।

जटिल संख्याएँ फॉर्म में लिखी जाती हैं x + yj, जहाँ x वास्तविक भाग है और y काल्पनिक भाग है।

हम type()फ़ंक्शन का उपयोग यह जानने के लिए कर सकते हैं कि कोई वर्ग या मान किस वर्ग का है और isinstance()यह जाँचने के लिए कार्य करता है कि वह किसी विशेष वर्ग का है या नहीं।

आइए एक उदाहरण देखें:

 a = 5 print(type(a)) print(type(5.0)) c = 5 + 3j print(c + 3) print(isinstance(c, complex))

जब हम उपरोक्त कार्यक्रम चलाते हैं, तो हमें निम्न आउटपुट मिलते हैं:

 ((+ ३ जे) सत्य

जबकि पूर्णांक किसी भी लम्बाई के हो सकते हैं, एक फ़्लोटिंग-पॉइंट संख्या केवल 15 दशमलव स्थानों तक सटीक होती है (16 वां स्थान गलत है)।

हर दिन हम जिन नंबरों से निपटते हैं, वे दशमलव (बेस 10) नंबर सिस्टम के होते हैं। लेकिन कंप्यूटर प्रोग्रामर (आमतौर पर एम्बेडेड प्रोग्रामर) को बाइनरी (बेस 2), हेक्साडेसिमल (बेस 16) और ऑक्टल (बेस 8) नंबर सिस्टम के साथ काम करने की आवश्यकता होती है।

पायथन में, हम उस संख्या से पहले उपसर्ग लगाकर इन संख्याओं का प्रतिनिधित्व कर सकते हैं। निम्न तालिका इन उपसर्गों को सूचीबद्ध करती है।

संख्या प्रणाली	उपसर्ग
बाइनरी	'0 बी' या '0 बी'
अष्टदल	'0o' या '0O'
हेक्साडेसिमल	'0x' या '0X'

यहां कुछ उदाहरण दिए गए हैं

 # Output: 107 print(0b1101011) # Output: 253 (251 + 2) print(0xFB + 0b10) # Output: 13 print(0o15)

जब आप प्रोग्राम चलाते हैं, तो आउटपुट होगा:

 १० 13 २५३ १३

रूपांतरण टाइप करें

हम एक प्रकार की संख्या को दूसरे में बदल सकते हैं। इसे ज़बरदस्ती के रूप में भी जाना जाता है।

यदि ऑपरेंड में से कोई एक फ्लोट है, तो अतिरिक्त, स्वचालित रूप से फ्लोट करने के लिए घटाव पूर्णांक जैसे ऑपरेशन।

 >>> 1 + 2.0 3.0

हम ऊपर देख सकते हैं कि 1 (पूर्णांक) इसके अतिरिक्त 1.0 (फ्लोट) में सम्‍मिलित है और परिणाम एक फ्लोटिंग प्‍वाइंट नंबर भी है।

हम अंतर्निहित कार्यों का भी उपयोग कर सकते हैं int(), float()और complex()प्रकारों के बीच स्पष्ट रूप से परिवर्तित करने के लिए। इन कार्यों को तार से भी परिवर्तित किया जा सकता है।

 >>> int(2.3) 2 >>> int(-2.8) -2 >>> float(5) 5.0 >>> complex('3+5j') (3+5j)

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

पायथन दशमलव

पायथन में निर्मित वर्ग फ्लोट कुछ गणना करता है जो हमें विस्मित कर सकता है। हम सभी जानते हैं कि 1.1 और 2.2 का योग 3.3 है, लेकिन पायथन असहमत लगता है।

 >>> (1.1 + 2.2) == 3.3 False

क्या हो रहा है?

यह पता चला है कि फ्लोटिंग-पॉइंट नंबर कंप्यूटर हार्डवेयर में द्विआधारी अंशों के रूप में कार्यान्वित किए जाते हैं क्योंकि कंप्यूटर केवल बाइनरी (0 और 1) को समझता है। इस कारण से, अधिकांश दशमलव भिन्न जिन्हें हम जानते हैं, हमारे कंप्यूटर में सटीक रूप से संग्रहीत नहीं किए जा सकते हैं।

एक उदाहरण लेते हैं। हम दशमलव संख्या के रूप में अंश 1/3 का प्रतिनिधित्व नहीं कर सकते। यह 0.33333333 देगा … जो असीम रूप से लंबा है, और हम इसे केवल अनुमानित कर सकते हैं।

यह पता चलता है कि दशमलव अंश 0.1 में 0.000110011001100110011 का असीम रूप से लंबे द्विआधारी अंश का परिणाम होगा … और हमारा कंप्यूटर केवल इसकी एक सीमित संख्या को संग्रहीत करता है।

यह केवल लगभग 0.1 होगा, लेकिन कभी भी बराबर नहीं होगा। इसलिए, यह हमारे कंप्यूटर हार्डवेयर की सीमा है न कि पायथन में एक त्रुटि।

 >>> 1.1 + 2.2 3.3000000000000003

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

आइए देखते हैं अंतर:

 import decimal print(0.1) print(decimal.Decimal(0.1))

आउटपुट

 0.1 0.1000000000000000055511151231257827021181583404541015625

इस मॉड्यूल का उपयोग तब किया जाता है जब हम स्कूल में सीखी गई दशमलव गणनाओं को पूरा करना चाहते हैं।

यह महत्व भी रखता है। हम जानते हैं कि 25.50 किलोग्राम 25.5 किलोग्राम से अधिक सटीक है क्योंकि इसमें एक की तुलना में दो महत्वपूर्ण दशमलव स्थान हैं।

 from decimal import Decimal as D print(D('1.1') + D('2.2')) print(D('1.2') * D('2.50'))

आउटपुट

 ३.३ ३.०००

Notice the trailing zeroes in the above example.

We might ask, why not implement Decimal every time, instead of float? The main reason is efficiency. Floating point operations are carried out must faster than Decimal operations.

When to use Decimal instead of float?

We generally use Decimal in the following cases.

• When we are making financial applications that need exact decimal representation.
• When we want to control the level of precision required.
• When we want to implement the notion of significant decimal places.

Python Fractions

Python provides operations involving fractional numbers through its fractions module.

A fraction has a numerator and a denominator, both of which are integers. This module has support for rational number arithmetic.

We can create Fraction objects in various ways. Let's have a look at them.

 import fractions print(fractions.Fraction(1.5)) print(fractions.Fraction(5)) print(fractions.Fraction(1,3))

Output

 3/2 5 1/3

While creating Fraction from float, we might get some unusual results. This is due to the imperfect binary floating point number representation as discussed in the previous section.

Fortunately, Fraction allows us to instantiate with string as well. This is the preferred option when using decimal numbers.

 import fractions # As float # Output: 2476979795053773/2251799813685248 print(fractions.Fraction(1.1)) # As string # Output: 11/10 print(fractions.Fraction('1.1'))

Output

 2476979795053773/2251799813685248 11/10

This data type supports all basic operations. Here are a few examples.

 from fractions import Fraction as F print(F(1, 3) + F(1, 3)) print(1 / F(5, 6)) print(F(-3, 10)> 0) print(F(-3, 10) < 0)

Output

 2/3 6/5 False True

Python Mathematics

Python offers modules like math and random to carry out different mathematics like trigonometry, logarithms, probability and statistics, etc.

 import math print(math.pi) print(math.cos(math.pi)) print(math.exp(10)) print(math.log10(1000)) print(math.sinh(1)) print(math.factorial(6))

Output

 3.141592653589793 -1.0 22026.465794806718 3.0 1.1752011936438014 720

Here is the full list of functions and attributes available in the Python math module.

 import random print(random.randrange(10, 20)) x = ('a', 'b', 'c', 'd', 'e') # Get random choice print(random.choice(x)) # Shuffle x random.shuffle(x) # Print the shuffled x print(x) # Print random element print(random.random())

जब हम उपरोक्त प्रोग्राम चलाते हैं तो हमें आउटपुट निम्न प्रकार से मिलता है। (यादृच्छिक व्यवहार के कारण मान भिन्न हो सकते हैं)

 18 ई ('सी', 'ई', 'डी', 'बी', 'ए') 0.5682821194654443

यहां पायथन रैंडम मॉड्यूल में उपलब्ध कार्यों और विशेषताओं की पूरी सूची दी गई है।