संख्याएँ और अंकगणित

docs.scrimba.com

संख्याएँ लगभग हर प्रोग्राम में दिखाई देती हैं जो आप लिखते हैं। एक शॉपिंग कार्ट एक कीमत जोड़ता है। एक खेल एक स्कोर अपडेट करता है। एक स्क्रिप्ट गिनती करती है कि कोई चीज़ कितनी बार हुई। Python आपको अंकगणितीय संचालक देता है जो कागज़ के गणित की तरह काम करते हैं, साथ ही कुछ ऐसे भी हैं जो शुरुआत से ही जानने लायक हैं।

Python के अंकगणितीय संचालक मानक सेट के साथ-साथ पूर्णांक विभाजन, मॉड्यूलो, और घातांक को कवर करते हैं। कुछ व्यवहार अन्य भाषाओं से अलग तरीकों से भिन्न होते हैं जो व्यावहारिक रूप से मायने रखते हैं: / हमेशा एक float देता है, floor division ऋणात्मक अनंत की ओर गोल करता है, और modulo true modulo शब्दार्थ का पालन करता है।

Python पूर्णांकों में overflow नहीं होता है (fixed-size पूर्णांकों वाली भाषाओं में जो wrap-around या त्रुटि होती है): वे जितनी मेमोरी अनुमति देती है उतने बड़े हो जाते हैं। Floats सामान्य double-precision दशमलव हैं, अधिकांश काम के लिए ठीक हैं लेकिन पैसे के लिए कभी सटीक नहीं हैं। अंकगणितीय संचालक गणितीय परिभाषाओं का पालन करते हैं न कि C सम्मेलन का जो कई भाषाएँ कॉपी करती हैं: // floor division है (यह ऋणात्मक अनंत की ओर गोल करता है) और % भाजक का चिन्ह धारण करता है, लाभांश का नहीं। दोनों विकल्प यह सुनिश्चित करते हैं कि आपके इनपुट सकारात्मक हों या नकारात्मक, एक ही परिणाम मिले, जो चक्रीय और लपेटने के लिए वह व्यवहार है जो आप चाहते हैं।

संचालक

गणित से चार संचालक (+, -, *, /) बिल्कुल वैसे ही काम करते हैं जैसे आप अपेक्षा करेंगे। Python तीन और जोड़ता है जिनका उपयोग आप लगातार करेंगे: पूर्णांक विभाजन, शेषफल, और घातांक।

मानक चार संचालक अपेक्षा के अनुसार व्यवहार करते हैं, एक उल्लेखनीय नियम के साथ: / हमेशा एक float देता है, भले ही परिणाम एक पूरी संख्या हो। तीन अतिरिक्त संचालक आपको किसी भी अतिरिक्त काम के बिना व्यक्त करने में सक्षम बनाते हैं।

प्रत्येक संचालक एक dunder method से जुड़ा होता है (एक विधि जिसका नाम double underscores से शुरू होता है जिसे Python पर्दे के पीछे कॉल करता है): + से __add__, // से __floordiv__, % से __mod__, ** से __pow__, और इसी तरह। व्यावहारिक लाभ यह है कि आपकी अपनी classes उन विधियों को परिभाषित कर सकती हैं और फिर सीधे + या * के साथ काम कर सकती हैं, उसी तरह जैसे एक अंतर्निर्मित संख्या करती है। एक int और एक float को एक ऑपरेशन में मिलाने से हमेशा एक float मिलता है, और / इससे कोई फर्क नहीं पड़ता कि आप इसे क्या देते हैं एक float देता है।

price = 12.99
quantity = 3

print(price * quantity)   # 38.97
print(price + 2)          # 14.99
print(price - 1.00)       # 11.99

संचालक	नाम	उदाहरण	परिणाम
+	जोड़	5 + 3	8
-	घटाव	5 - 3	2
*	गुणा	5 * 3	15
/	विभाजन	5 / 3	1.6666...
//	पूर्णांक विभाजन	5 // 3	1
%	शेषफल	5 % 3	2
**	घातांक	5 ** 3	125

Junoसंचालक+, -, *, / कागज़ के गणित की तरह व्यवहार करते हैं। तीन अतिरिक्त जल्दी सीखने लायक हैं: // एक पूरी संख्या तक विभाजित करता है, % आपको शेषफल देता है, और ** एक शक्ति तक बढ़ाता है। मैं % का उपयोग कहीं अधिक करता हूँ जितना मैं कभी अपेक्षा करता था।

Junoसंचालक चार मूल अपेक्षा के अनुसार काम करते हैं, एक नियम के साथ: / हमेशा एक float देता है। अतिरिक्त // पूर्णांक विभाजन के लिए, % शेषफल के लिए, और ** घातांक के लिए हैं। प्रत्येक एक सहायक लिखने से बचाता है।

Junoसंचालक प्रत्येक संचालक एक dunder में जाता है, तो एक class जो __add__ या __mul__ को परिभाषित करता है सीधे + और * में जाता है। मिश्रित int और float हमेशा float में चौड़े होते हैं, और / इससे कोई फर्क नहीं पड़ता कि आप इसे क्या देते हैं एक float देता है।

विभाजन: / बनाम //

/ आपको सटीक दशमलव परिणाम देता है, भले ही उत्तर एक पूरी संख्या हो। // अंशात्मक भाग को छोड़ देता है और ऋणात्मक अनंत की ओर फर्श करता है। सकारात्मक संख्याओं के लिए इसका मतलब दशमलव को काटना है, लेकिन ऋणात्मक संख्याओं के लिए यह शून्य से एक कदम और दूर जाता है:

/ हमेशा एक float देता है, भले ही इनपुट पूर्णांक हों। // परिणाम की मंजिल है: सबसे बड़ा पूर्णांक जो सच्चे परिणाम से कम या बराबर है। सकारात्मक संख्याओं के लिए यह trunc जैसा ही है। ऋणात्मक संख्याओं के लिए, यह नहीं है:

/ true division है और हमेशा एक float देता है। // floor division है: यह सच्चे भागफल को ऋणात्मक अनंत की ओर गोल करता है न कि शून्य की ओर, जो कि कई अन्य भाषाएँ करती हैं। कारण कि यह व्यावहारिक रूप से मायने रखता है: Python का // और % हर पूर्णांक इनपुट के लिए a == (a // b) * b + (a % b) को संतुष्ट करता है, ऋणात्मक भी। Truncating division ऋणात्मक के लिए उस पहचान को तोड़ता है, इसलिए कोई भी चक्रीय या लपेटने का तर्क जो आप यहाँ लिखते हैं बिना चिन्ह-केस किए सही रहता है।

10 / 2     # 5.0   (हमेशा float, भले ही यह समान रूप से विभाजित हो)
10 / 3     # 3.3333333333333335

10 // 3    # 3
7 // 2     # 3
-7 // 2    # -4    (ऋणात्मक अनंत की ओर फर्श करता है, शून्य की ओर नहीं)

आप ज़्यादातर सकारात्मक संख्याओं के साथ // का उपयोग करेंगे। जब वे दिखाई दें तो ऋणात्मक व्यवहार को ध्यान में रखें।

Junoविभाजन: / बनाम /// हमेशा एक दशमलव को हाथ करता है, भले ही यह समान रूप से विभाजित हो: 4 / 2 2.0 है। // अंशात्मक भाग को छोड़ देता है, लेकिन ऋणात्मक देखें: -7 // 2 -4 है, -3 नहीं, क्योंकि यह काटने के बजाय फर्श करता है। पहली बार मुझे यह मिला तो मुझे चकित कर गया।

Python इसे floor division कहता है क्योंकि यह गणितीय floor function को लागू करता है। अन्य भाषाएँ शून्य की ओर काटती हैं, ऋणात्मक के लिए एक अलग परिणाम देती हैं। नाम // एक संकेत है: विभाजित करें, फिर फर्श करें।

Junoविभाजन: / बनाम /// हमेशा एक float देता है, भले ही 4 / 2 2.0 दे। // truncate के बजाय फर्श करता है, इसलिए -7 // 2 -4 है। सकारात्मक संख्याओं के लिए दोनों समान दिखते हैं, अंतर केवल ऋणात्मक पर खुलता है।

// floor(a / b) की गणना करता है, truncation नहीं। यह floats पर भी काम करता है: 7.5 // 2 3.0 है, floored quotient एक int के बजाय एक float के रूप में हाथ किया गया।

Junoविभाजन: / बनाम //// भागफल को फर्श करता है, इसलिए यह हर इनपुट पर a == (a // b) * b + (a % b) को संतुष्ट करता है, ऋणात्मक सब कुछ भी। वह एक संपत्ति है चक्रीय तर्क के लिए। ध्यान दें कि एक float operand // को एक float देता है, जैसे 7.5 // 2 3.0 देता है।

शेषफल संचालक %

% आपको पूर्णांक विभाजन के बाद जो बचा है उसे देता है। यदि 10 // 3 3 है (क्योंकि 3 10 में तीन बार जाता है), तो 10 % 3 1 है (क्योंकि 3 × 3 = 9, और 10 - 9 = 1)। सबसे आम उपयोग यह जांचना है कि कोई संख्या सम है या विषम।

% modulo संचालक है। सम/विषम जांच सबसे आम उपयोग है, लेकिन यह किसी भी चक्रीय या लपेटने की समस्या को सामान्य करता है: एक काउंटर को एक सीमा के भीतर रखना, वस्तुओं को समूहों में वितरित करना, एक क्रम को दोहराना। पैटर्न हमेशा value % limit है, जो 0 और limit - 1 के बीच कुछ देता है।

Python का % true modulo है: परिणाम हमेशा भाजक का चिन्ह धारण करता है। कई अन्य भाषाएँ लाभांश का चिन्ह लेती हैं, इसलिए वे जहाँ Python 2 देता है वहाँ -7 % 3 के लिए -1 देंगे। Python का उत्तर modulo को a - (a // b) * b के रूप में परिभाषित करने से निकलता है जहाँ // ऋणात्मक अनंत की ओर फर्श करता है। अदायगी यह है कि value % limit भले ही value नकारात्मक हो जाए, 0 से limit - 1 के भीतर रहता है, तो एक सूचकांक जो एक सूची के अंत के चारों ओर लपेटता है एक guard clause के बिना सीमा में आता है।

10 % 3    # 1
10 % 2    # 0  (समान रूप से विभाजित होता है)
10 % 7    # 3

6 % 2     # 0  (सम)
7 % 2     # 1  (विषम)

Junoशेषफल संचालक %% पूर्णांक विभाजन के बाद बचा हुआ है। 10 % 3 1 है क्योंकि 3 10 में तीन बार फिट होता है 1 के साथ बचा हुआ। आप ज़्यादातर इसे सम/विषम जांच के रूप में देखेंगे: n % 2 सम के लिए 0, विषम के लिए 1 है।

Junoशेषफल संचालक %% modulo है, और यह सम/विषम से परे जाता है: जब भी आपको एक value को एक सीमा के भीतर रखने की आवश्यकता हो, value % limit इसे 0 से limit - 1 तक लपेटता है। काउंटर, समूह असाइनमेंट, दोहराई जाने वाले चक्र, सभी एक ही आकार।

Junoशेषफल संचालक %% भाजक के चिन्ह का पालन करता है, इसलिए -7 % 3 2 है, -1 नहीं। वह value % limit को नकारात्मक इनपुट के साथ सीमा में रखता है, एक लपेटने वाले सूचकांक के लिए कोई guard clause नहीं।

घातांक **

** एक संख्या को एक शक्ति तक बढ़ाता है। दो asterisks का उपयोग करें, ^ प्रतीक नहीं (जिसका Python में कुछ और मतलब है):

** घातांक है। यह floats के साथ भी काम करता है, जो आपको एक अलग function call के बजाय fractional powers के रूप में roots व्यक्त करने देता है:

** एक शक्ति तक बढ़ाता है, और fractional-power form सुविधाजनक है: n ** 0.5 कुछ भी import किए बिना एक square root है। दो int operands एक int देते हैं, कोई float operand एक float देता है। बड़े या सटीक काम पर इसे पहुंचने से पहले जानने के लिए एक चीज़: 9 ** 0.5 float मaths के माध्यम से जाता है, इसलिए यह कुछ इनपुट के लिए 2.9999999999999996 पर आ सकता है। जब exactness मायने रखता है, math.isqrt() integer roots के लिए और math.pow() Modules अध्याय में cover किए गए tools हैं।

2 ** 10    # 1024
3 ** 3     # 27
9 ** 0.5   # 3.0  (square root: 0.5 की शक्ति तक बढ़ाएं)

Junoघातांक **** एक संख्या को एक शक्ति तक बढ़ाता है, तो 2 ** 10 1024 है। एक fractional power आपको एक root देता है: 9 ** 0.5 3.0 है। एक trap प्रतीक है, ** का उपयोग करें, ^ नहीं, जो Python में कुछ unrelated करता है।

Junoघातांक **** घातांक है, और यह floats लेता है, तो 9 ** 0.5 आपको कोई अलग function call के बिना एक square root देता है। जब आप एक quick root inline चाहते हैं तो fractional-power form तक पहुंचें।

Junoघातांक ** दो ints एक int देते हैं, कोई float एक float देता है। ** 0.5 root trick के साथ catch यह है कि यह float मaths के माध्यम से चलता है और drift कर सकता है, तो जब exactness की गणना करता है तब math.isqrt() या math.pow() तक पहुंचें।

संचालक प्राधिकार

Python मानक गणित क्रम का पालन करता है: घातांक पहले, फिर गुणा और विभाजन, फिर जोड़ और घटाव। जब आप निश्चित नहीं हैं, तो parentheses का उपयोग करें। वे intention को स्पष्ट करते हैं और कुछ नहीं लगते:

Python मानक PEMDAS/BODMAS क्रम का पालन करता है। जो हिस्सा लोगों को trip करता है: /, //, और % सभी एक ही precedence स्तर पर हैं और जब mixed हों तो left to right मूल्यांकन करते हैं। Parentheses free हैं; उपयोग करें जब भी order एक नज़र पर स्पष्ट न हो:

Precedence उच्चतम से निम्नतम तक अंकगणितीय संचालकों में: **, फिर unary - (एक single value के सामने एक minus चिन्ह), फिर * / // % (left-to-right जब वे एक स्तर साझा करते हैं), फिर + -। एक trap जो असली code में काटता है: -2 ** 2 -(2 ** 2) है, जो -4 है, क्योंकि ** leading minus से ज़्यादा tightly bind करता है। अगर आप कभी एक value को square करते हैं जो negative हो सकता है, तो इसे (-2) ** 2 के रूप में parenthesise करें या चिन्ह बिना किसी त्रुटि को चेतावनी के गलत होगा।

2 + 3 * 4      # 14, 20 नहीं
2 ** 3 + 1     # 9,  512 नहीं
10 - 4 / 2     # 8.0, 3.0 नहीं

(2 + 3) * 4    # 20
10 / (2 + 3)   # 2.0

Junoसंचालक प्राधिकार कागज़ के गणित के समान क्रम: शक्तियाँ पहले, फिर गुणा और विभाजन, फिर जोड़ और घटाव। जब order एक नज़र पर स्पष्ट न हो, parentheses जोड़ें। वे कुछ नहीं लगते और वे बिल्कुल spell करते हैं कि आपका मतलब क्या है।

Junoसंचालक प्राधिकार मानक PEMDAS क्रम, एक snag के साथ: /, // और % सभी एक ही स्तर पर बैठते हैं और जब mixed हों तो left to right चलते हैं। वह left-to-right नियम वह हिस्सा है जो लोग misread करते हैं, तो parenthesise करें जब भी grouping स्पष्ट न हो।

Junoसंचालक प्राधिकार Trap unary minus है जो `**` से looser bind करता है, तो -2 ** 2 -4 है। कुछ भी square करें जो negative हो सकता है जैसा (-2) ** 2, या चिन्ह इसे flag करने के लिए कोई त्रुटि के साथ फ्लिप करेगा।

कैसे int और float परस्पर क्रिया करते हैं

Python का एक सुसंगत नियम है: / हमेशा एक दशमलव देता है, भले ही 4 / 2 2.0 दे। कोई भी operation जो एक पूर्णांक और एक दशमलव को मिलाता है एक दशमलव भी देता है। जब आपको एक पूरी संख्या की आवश्यकता हो, // का उपयोग करें या int() के साथ convert करें।

Type नियम predictable हैं: / हमेशा float देता है। // और % दो integers के साथ int देते हैं। कोई भी operation जो int और float को मिलाता है float देता है। इसका मतलब 4 / 2 2.0 है, 2 नहीं, जो मायने रखता है जब आपको एक integer की आवश्यकता हो (उदाहरण के लिए, एक सूचकांक के रूप में उपयोग करने के लिए)।

नियम fixed है और internalise लायक है: int जब भी दोनों mix हों float में चौड़े होते हैं, / हमेशा एक float देता है, और // एक int देता है केवल जब दोनों operands int हों। bug जो यह रोकता है एक float कुछ में sneaking है जिसे एक पूरी संख्या की आवश्यकता है, जैसे एक list सूचकांक या एक dictionary key, जहाँ 2.0 और 2 interchangeable नहीं हैं। जब एक calculation एक float produce कर सकता है और आपको एक int की आवश्यकता हो, उस बिंदु पर int() के साथ convert करें न कि यह उम्मीद करते हुए कि विभाजन पूरा आया।

4 / 2      # 2.0   (float, हमेशा)
4 // 2     # 2     (int)
4 + 2      # 6     (int)
4 + 2.0    # 6.0   (float)
4 * 0.5    # 2.0   (float)

Junoकैसे int और float परस्पर क्रिया करते हैं/ हमेशा एक दशमलव देता है, तो 4 / 2 2.0 है, 2 नहीं। कहीं भी एक पूरी संख्या को एक दशमलव के साथ मिलाएँ और आप एक दशमलव प्राप्त करते हैं। जब आपको एक पूरी संख्या की आवश्यकता हो, // के लिए पहुंचें या इसे int() में लपेटें।

Junoकैसे int और float परस्पर क्रिया करते हैं/ हमेशा float है, // और % दो ints पर int रहते हैं, और कोई भी int एक float के साथ float आता है। जो लोगों को catches है वह 4 / 2 2.0 है जब आप एक सूचकांक चाहते हैं।

Junoकैसे int और float परस्पर क्रिया करते हैं एक stray float `/` से कुछ को तोड़ता है जिसे एक exact int की आवश्यकता है, जैसे एक सूचकांक या एक dict key जहाँ 2.0 2 नहीं है। उस boundary पर int() के साथ convert करें न कि विभाजन के पूरा आने पर विश्वास करते हुए।

Float परिशुद्धि

एक gotcha है जो लगभग हर किसी को किसी बिंदु पर हैरान करता है:

0.1 + 0.2   # 0.30000000000000004

वह tiny error एक Python bug नहीं है। कंप्यूटर दशमलव संख्याओं को बाइनरी में store करते हैं, और कुछ values जैसे 0.1 को सटीक रूप से represent नहीं किया जा सकता। यह कैसे similar है 1/3 को दशमलव में सटीक रूप से नहीं लिखा जा सकता। अधिकांश रोज़मर्रा की गणनाओं के लिए यह matter नहीं करता। धन को display करने के लिए, round() या :.2f format specifier output को tidy रखेगा।

Floats आपको लगभग 15 से 16 significant decimal digits की precision देते हैं। imprecision सामने आता है क्योंकि कुछ fractions को बाइनरी में सटीक रूप से store नहीं किया जा सकता, तो 0.1 + 0.2 0.30000000000000004 produce करता है। drift केवल तब दिखाई देता है जब आप raw value को inspect करते हैं; :.2f या round() के साथ formatting इसे output में छुपाता है।

Financial काम के लिए जहाँ fractions of a cent accumulate, Python standard library में decimal.Decimal प्रदान करता है जिसमें exact base-10 अंकगणित होता है। यह Modules अध्याय में cover किया गया है।

एक float बाइनरी (base 2) में संख्याओं को store करता है, और कोई भी fraction जिसका denominator दो की शक्ति नहीं है (जैसे 1/10) का बाइनरी form नहीं है, उसी तरह 1/3 का दशमलव form नहीं है। वह पूरा कारण है 0.1 + 0.2 0.30000000000000004 पर आता है। error per operation tiny है, लेकिन यह अंकगणित की एक long chain में accumulate होता है, तो एक ही total को compute करने के दो तरीके last few digits में disagree कर सकते हैं।

Trap को रोकने वाला नियम: पैसे के लिए कभी float का उपयोग न करें, और floats को exact equality के साथ == से test न करें। Exact base-10 अंकगणित के लिए decimal.Decimal तक पहुंचें (billing, accounting), या exact ratios के लिए fractions.Fraction बिना किसी rounding के बिल्कुल। दोनों Python के standard library में ship होते हैं, Modules अध्याय में cover किए गए।

JunoFloat परिशुद्धि कंप्यूटर दशमलव को बाइनरी में store करते हैं, और कुछ values जैसे 0.1 का कोई exact binary form नहीं है, तो 0.1 + 0.2 0.30000000000000004 आता है। यह Python bug नहीं है, हर भाषा यह करता है। रोज़मर्रा के output के लिए, round() या :.2f इसे tidy रखता है।

JunoFloat परिशुद्धि बाइनरी हर दशमलव को hold नहीं कर सकता सटीक रूप से, तो 0.1 + 0.2 0.30000000000000004 में drift करता है। अधिकांश मaths के लिए fine, और :.2f या round() display को tidy करता है। जब cents को add up करना है, तो decimal.Decimal में switch करें।

JunoFloat परिशुद्धि नियम जो आपको save करता है: money के लिए कोई floats नहीं, और floats पर कभी == नहीं, क्योंकि error operations की chain में accumulate होता है। Exact base-10 के लिए decimal.Decimal और exact ratios के लिए fractions.Fraction का उपयोग करें।

Readable number literals

Python आपको number literals में underscores रखने देता है बड़ी संख्याओं को ज़्यादा readable बनाने के लिए। Python उन्हें completely ignore करता है; वे आपके लिए हैं:

Underscores numeric literal में कहीं भी valid हैं और parsing के दौरान stripped होते हैं जिसका value पर कोई effect नहीं होता। Constants में thousands separators के लिए उपयोगी और binary या hex literals में digits को group करने के लिए:

Underscores Python को देखने से पहले stripped होते हैं, तो उनका value पर zero effect होता है। वे integers, floats, और based literals सभी में काम करते हैं (0xFF_FF, 0b1010_0001, 1_234.567_890), जो उन्हें एक hex constant में bytes को group करने के लिए handy बनाता है, केवल एक decimal में thousands नहीं। केवल restrictions: एक underscore start पर, end पर, या decimal point के बगल में या exponent marker के बगल में नहीं बैठ सकता।

population = 8_100_000_000
distance_km = 384_400
pi_approx = 3.141_592_653

JunoReadable number literals एक लंबी संख्या में underscores drop करें इसे readable बनाने के लिए: 8_100_000_000 8100000000 के समान value है। Python उन्हें बिल्कुल ignore करता है, वे आपकी आँखों के लिए हैं, interpreter के लिए नहीं।

JunoReadable number literals Underscores numeric literal के अंदर कहीं भी valid हैं और parse time पर vanish होते हैं, तो value unchanged है। Constants में thousands separators के लिए अच्छे, और equally binary या hex में digits को group करने के लिए उपयोगी।

JunoReadable number literals Underscores integers, floats और based literals में cosmetic हैं, तो 0xFF_FF और 0b1010_0001 ज़्यादा cleanly read करते हैं। केवल नियम: start पर नहीं, end पर नहीं, या decimal point या exponent marker के बगल पर नहीं।

उपयोगी अंतर्निर्मित functions

abs()

abs() absolute value देता है: हमेशा सकारात्मक, input के चिन्ह के regardless। इसका उपयोग करें जब आप परवाह करते हों कि एक संख्या शून्य से कितनी दूर है, न कि किस दिशा में।

abs() एक संख्या का magnitude देता है। Integers और floats पर काम करता है। Distance calculations, error margins, और कोई भी situation जहाँ direction irrelevant है और आपको केवल value का size चाहिए के लिए उपयोगी।

abs() एक संख्या का magnitude देता है, return type input को match करता है: एक int in एक int out देता है, एक float एक float देता है। रोज़मर्रा का उपयोग है कैसे दूर दो values एक target से बैठते हैं compare करना बिना caring किस side पर वे fall करें, उदाहरण के लिए abs(measured - expected) < tolerance as a tolerance check, जो दो comparisons के बजाय एक signed range के विपरीत ज़्यादा clearly read करता है।

abs(-5)     # 5
abs(3.7)    # 3.7
abs(-0.5)   # 0.5

Junoabs()abs() चिन्ह को strip करता है और सकारात्मक size को हाथ करता है: abs(-5) 5 है, abs(3.7) 3.7 है। जब आप care करते हैं कि एक संख्या शून्य से कितनी दूर है, न कि किस दिशा में लीन करता है, के लिए पहुंचें।

Junoabs()abs() एक int या float का magnitude देता है, direction discarded। यह distance और error-margin checks लिखने के लिए clean तरीका है, कहीं चिन्ह सवाल का हिस्सा नहीं है।

Junoabs()abs() input type को रखता है, एक int एक int रहता है। pattern worth keeping है abs(measured - expected) < tolerance: एक tolerance check two comparisons के बजाय एक signed range के चारों ओर।

round()

round() डिफ़ॉल्ट रूप से nearest integer को round करता है। decimal places की एक specific संख्या को रखने के लिए एक दूसरा argument पास करें:

round(3.7)          # 4
round(3.2)          # 3
round(3.14159, 2)   # 3.14

जानने लायक एक चीज़: round(2.5) 2 देता है, 3 नहीं। Python जब एक value दो options के बीच सटीक तरीके से halfway हो तो nearest even number को round करता है।

round() banker's rounding का उपयोग करता है: जब value सटीक halfway हो तो यह nearest even number को round करता है बजाय हमेशा ऊपर के। यह statistical काम में accumulated error को minimize करता है लेकिन आपको surprise कर सकता है अगर आप expect करते हैं 0.5 को हमेशा ऊपर round करने के लिए:

round(2.5)   # 2  (nearest even को round करता है)
round(3.5)   # 4
round(4.5)   # 4  (5 नहीं)
round(3.14159, 2)   # 3.14

round() round-half-to-even (banker's rounding) का उपयोग करता है: एक exact tie nearest even integer को जाता है, हमेशा ऊपर नहीं। यह एक लंबे column of figures में एक दिशा में rounding errors को bias करने से रखता है, यही कारण है कि यह statistical काम के लिए default है। दो practical cautions। पहले, एक float tie अक्सर exact tie नहीं है जब यह बाइनरी में है, तो round(2.675, 2) 2.67 देता है, 2.68 नहीं, क्योंकि 2.675 सटीक रूप से store नहीं किया जा सकता। दूसरा, जब आपको predictable currency rounding की आवश्यकता हो, तो यह decimal.Decimal के साथ करें एक explicit rounding mode के साथ बजाय floats पर round() पर rely करने के।

round(2.5)   # 2
round(3.5)   # 4
round(4.5)   # 4

Junoround()round(x) nearest whole number को जाता है, round(x, n) n decimal places को रखता है। Surprise: एक value जो सटीक halfway बैठता है nearest even number को round करता है, तो round(2.5) 2 है, 3 नहीं।

Junoround()round() banker's rounding का उपयोग करता है, तो exact halves nearest even number को जाते हैं: round(2.5) 2 है, round(4.5) 4 है। यह aggregate काम में bias को cuts करता है, लेकिन expect करें जब आप assumed halves हमेशा ऊपर round करते हैं।

Junoround() Banker's rounding plus बाइनरी means round(2.675, 2) 2.67 है, क्योंकि 2.675 hood के तहत एक exact tie नहीं है। Currency के लिए, decimal.Decimal के साथ round करें एक chosen mode के साथ बजाय floats पर round() पर trusting।

divmod()

divmod() एक ही call में quotient और remainder दोनों देता है। यह values की एक pair, एक tuple (Tuples and sets अध्याय में cover किया गया) return करता है, जिसे आप एक साथ दो names को assign कर सकते हैं:

divmod(a, b) (a // b, a % b) के बराबर है लेकिन एक single step में computed। इसका उपयोग करें जब आपको दोनों values की आवश्यकता हो: pagination, time conversion, या items को groups में distribute करना।

divmod(a, b) division एक बार करता है और floor quotient और modulo remainder दोनों को एक pair के रूप में return करता है, तो आप // के माध्यम से एक ही division को recomputing से avoid करते हैं और फिर %। यह cleanest read करता है जहाँ आपको दोनों halves की आवश्यकता है: time conversion (divmod(seconds, 60)), pagination, या fixed-size rows पर items को lay करना।

divmod(10, 3)   # (3, 1): quotient 3, remainder 1
divmod(7, 2)    # (3, 1)
divmod(9, 3)    # (3, 0)

quotient, remainder = divmod(10, 3)
print(quotient)    # 3
print(remainder)   # 1

Junodivmod()divmod(a, b) quotient और remainder को together हाथ करता है: divmod(10, 3) (3, 1) है। आप दोनों को एक साथ unpack कर सकते हैं quotient, remainder = divmod(10, 3) के साथ।

Junodivmod()divmod(a, b) (a // b, a % b) एक step में है। जब आपको दोनों pieces की आवश्यकता हो, जैसे time conversion या pagination के लिए पहुंचें, बजाय division को दो बार computing।

Junodivmod() एक division, दोनों results: divmod() redundant काम को skip करता है separate // और % का। यह best read करता है जहाँ आप दोनों halves anyway चाहते हैं, जैसे divmod(seconds, 60) या row layout।

व्यावहारिक में

एक tip calculator:

bill = 45.50
tip_rate = 0.18
tip = round(bill * tip_rate, 2)
total = round(bill + tip, 2)

print(f"Bill:  ${bill}")
print(f"Tip:   ${tip}")
print(f"Total: ${total}")

round() output को पैसे जैसा दिखने के लिए रखता है बजाय decimal places की एक long run के।

Pages को pagination के लिए count करना और progress को एक percentage के रूप में track करना:

total_items = 153
items_per_page = 10

full_pages, leftover = divmod(total_items, items_per_page)
total_pages = (total_items + items_per_page - 1) // items_per_page

print(f"Full pages: {full_pages}, leftover: {leftover}")
print(f"Total pages needed: {total_pages}")   # 16

total_files = 847
processed_files = 312

percent = round(processed_files / total_files * 100, 1)
print(f"Progress: {processed_files}/{total_files} ({percent}%)")

Ceiling division formula (n + d - 1) // d एक standard integer trick है float में convert किए बिना ऊपर round करने के लिए।

Min-max normalisation और percentage change: दो patterns जो data काम में लगातार दिखाई देते हैं:

# min-max normalisation: एक value को 0.0 से 1.0 range में scale करें
value = 75
minimum = 0
maximum = 100

normalised = (value - minimum) / (maximum - minimum)
print(f"Normalised: {normalised:.2f}")   # 0.75

# दो measurements के बीच percentage change
before = 1_200
after = 1_380

change = (after - before) / before * 100
print(f"Change: {change:.1f}%")          # 15.0%

दोनों patterns एक ratio तक reduce होते हैं: एक value एक reference range या एक reference magnitude के relative। float की precision अधिकांश analytical काम के लिए sufficient है; accumulated error केवल तब matters जब computation dozens of operations chain करता है या values को involve करता है जो कई orders of magnitude से differ करते हैं।