अंकगणित — भाग, शेषफल और दशमलव का जाल

वह समस्या जिसे हम हल कर रहे हैं

17 किताबें हैं, एक बॉक्स में 5 आती हैं। कितने बॉक्स लगेंगे, और कितनी किताबें बाहर बचेंगी?

इस सवाल का जवाब 17 / 5 नहीं है। वह 3.4 देता है, और 3.4 बॉक्स जैसी कोई चीज़ नहीं होती। आपको दो अलग जवाब चाहिए: कितने पूरे और कितना बचा। पायथन में दोनों के लिए अलग ऑपरेटर हैं, और यही दोनों सबसे ज़्यादा काम आते हैं — पेजिनेशन, सेकंड को घंटे-मिनट में बांटना, सम-विषम पता करना, सब यहीं से आता है।

साथ में एक और चीज़, जिसे पहली बार देखकर हर कोई रुक जाता है: पायथन में 0.1 + 0.2 लिखने पर जवाब 0.3 नहीं आता। ऐसा क्यों होता है, और इसके साथ क्या करना चाहिए, यह भी आज जान जाएंगे।

इस अध्याय के अंत तक आप कर पाएंगे

• सात अंकगणितीय ऑपरेटर इस्तेमाल करना
• बताना कि कौन सा कैलकुलेशन पहले चलता है, और ब्रैकेट कब चाहिए
• पहचानना कि // और % कहां इस्तेमाल होते हैं
• समझना कि / हमेशा दशमलव क्यों देता है, भाग पूरा बैठ जाए तब भी
• दशमलव संख्याओं की सटीकता की सीमा ध्यान में रखकर कैलकुलेशन लिखना

पहले से क्या आना चाहिए: वेरिएबल और टाइप।

सात ऑपरेटर

print(10 + 3)
print(10 - 3)
print(10 * 3)
print(10 / 3)
print(10 // 3)
print(10 % 3)
print(10 ** 3)

13
7
30
3.3333333333333335
3
1
1000

आखिरी तीन को थोड़ा समझाना ज़रूरी है:

• // — फ़्लोर डिवीज़न (पूरा भाग)। भाग देकर दशमलव से पहले वाला हिस्सा रखता है, बाकी छोड़ देता है
• % — मॉड्यूलो, यानी शेषफल। भाग देने के बाद कितना बचा
• ** — घात (power)। 10 ** 3 मतलब 10 का घन

/ हमेशा दशमलव देता है। 10 / 5 लिखें तब भी जवाब 2.0 आता है, 2 नहीं। अगर टाइप इस पर निर्भर करता कि भाग पूरा बैठा या नहीं, तो प्रोग्राम का बर्ताव अनिश्चित हो जाता, इसलिए पायथन यहां एक ही नियम रखता है — / मतलब float। पूर्ण संख्या चाहिए तो // इस्तेमाल करें।

बॉक्स वाली समस्या का हल

books = 17
per_box = 5

full_boxes = books // per_box
left_over = books % per_box

print("Full boxes:", full_boxes)
print("Left over :", left_over)

Full boxes: 3
Left over : 2

तीन बॉक्स भर जाएंगे, और 2 किताबें बाहर रहेंगी। // और % जोड़ी में आते हैं — एक बताता है "कितने पूरे", दूसरा बताता है "कितना बचा"।

यही जोड़ी और भी कई जगह काम आती है:

total_seconds = 500

minutes = total_seconds // 60
seconds = total_seconds % 60

print(minutes, "min", seconds, "sec")

8 min 20 sec

और % से सम-विषम पता किया जाता है। किसी भी संख्या को 2 से भाग दें तो शेषफल 0 (सम) या 1 (विषम) होता है:

print(14 % 2)
print(15 % 2)

0
1

आगे शर्तों (if) वाले अध्याय में यही शेषफल काम आएगा।

कौन सा कैलकुलेशन पहले चलता है

पायथन गणित का वही पुराना क्रम मानता है — गुणा-भाग पहले, जोड़-घटाना बाद में:

print(10 + 5 * 2)
print((10 + 5) * 2)

20
30

पहली लाइन में 5 * 2 पहले हुआ, फिर 10 जोड़ा गया। दूसरी लाइन में ब्रैकेट ने क्रम बदल दिया।

क्रम ऊपर से नीचे:

1. **
2. *, /, //, %
3. +, -

print(2 + 3 * 4 ** 2)

50

4 ** 2 है 16, फिर 3 * 16 है 48, फिर 2 + 48 है 50।

शक हो तो ब्रैकेट लगाएं। नियम याद हों तब भी (a + b) / 2 लिखना a + b / 2 लिखने से बेहतर है — क्योंकि अगली बार जो पढ़ेगा, उसे कोई नियम याद नहीं करना पड़ेगा। एक्स्ट्रा ब्रैकेट कोड को धीमा नहीं करते, बस साफ़ करते हैं।

नए लोगों से यह एक गलती सबसे ज़्यादा होती है — औसत निकालते समय:

a = 10
b = 20
c = 30

wrong = a + b + c / 3
right = (a + b + c) / 3

print("Wrong:", wrong)
print("Right:", right)

Wrong: 40.0
Right: 20.0

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

दशमलव का जाल

print(0.1 + 0.2)

0.30000000000000004

यह पायथन की गलती नहीं है। कंप्यूटर संख्याएं बेस टू (बाइनरी) में रखता है, और 0.1 को बाइनरी में बिल्कुल सही नहीं लिखा जा सकता — ठीक वैसे ही जैसे 1/3 को दशमलव में बिल्कुल सही नहीं लिखा जा सकता, 0.3333... चलता ही रहता है। इसलिए कंप्यूटर बहुत करीब की एक वैल्यू रखता है, और जोड़ने पर वह छोटा सा फ़र्क़ दिख जाता है। JavaScript, Java, C — सब जगह यही बर्ताव है।

इसके दो व्यावहारिक नतीजे:

एक — दिखाते समय round() इस्तेमाल करें:

total = 0.1 + 0.2
print(round(total, 2))

0.3

round(total, 2) का मतलब है दशमलव के बाद दो अंक तक रखो।

दो — दो दशमलव संख्याओं को == से कभी न मिलाएं:

print(0.1 + 0.2 == 0.3)

False

यही वह जाल है जो पैसों के कैलकुलेशन में गलत जवाब देता है। बड़े प्रोजेक्ट में पैसा float में नहीं रखा जाता — सबसे छोटी इकाई को पूर्ण संख्या के रूप में रखा जाता है (49.99 बन जाता है 4999), या decimal नाम का अलग मॉड्यूल इस्तेमाल होता है। अभी बस जान लें कि सीमा कहां है; मॉड्यूल बाद में आएंगे।

एक पूरा उदाहरण

packing.py:

# Work out packing and shipping for one order
total_items = 47
items_per_box = 6
box_cost = 35.5

full_boxes = total_items // items_per_box
loose_items = total_items % items_per_box

# A partly filled box still costs a full box
boxes_needed = full_boxes
if loose_items > 0:
    boxes_needed = full_boxes + 1

shipping = boxes_needed * box_cost

print("Items        :", total_items)
print("Full boxes   :", full_boxes)
print("Loose items  :", loose_items)
print("Boxes needed :", boxes_needed)
print("Shipping     :", round(shipping, 2))

Items        : 47
Full boxes   : 7
Loose items  : 5
Boxes needed : 8
Shipping     : 284.0

if वाली लाइन अभी सिखाई नहीं गई — अगले कुछ अध्यायों में वही आ रही है। अभी बस पढ़कर समझने की कोशिश करें: कुछ चीज़ें बॉक्स के बाहर रह जाएं, तो एक एक्स्ट्रा बॉक्स चाहिए।

जब कुछ टूट जाए

ZeroDivisionError: division by zero शून्य से भाग दिया गया है। गणित में भी यह परिभाषित नहीं है, इसलिए पायथन रुक जाता है। भाग देने से पहले देखना होगा कि भाजक शून्य तो नहीं — शर्तें सीखने के बाद यह आसान हो जाएगा।

10 / 5 ने 2.0 दिया, लेकिन मुझे 2 चाहिए // इस्तेमाल करें, या int(10 / 5) लिखें। पहला बेहतर है — इरादा कोड पढ़ते ही समझ आता है।

नेगेटिव संख्या पर // अलग जवाब दे रहा है -7 // 2 देता है -4, -3 नहीं। पायथन नीचे की तरफ़ राउंड करता है, शून्य की तरफ़ नहीं। नेगेटिव संख्याओं के साथ काम करें तो यह याद रखें।

कैलकुलेशन सही लग रहा है लेकिन जवाब गलत है ब्रैकेट गिनकर देखें, और हर स्टेप को अलग लाइन में तोड़कर प्रिंट करें। गलती लगभग हमेशा ऑपरेटर के क्रम में होती है।

दशमलव के बाद बहुत लंबी संख्या आ रही है यह एरर नहीं है, दशमलव संख्याओं का सामान्य बर्ताव है। दिखाते समय round() से छोटा कर लें।

आपकी बारी

time_split.py नाम की एक फ़ाइल लिखें, जो सेकंड की संख्या को घंटे, मिनट और सेकंड में बांटकर दिखाए।

total_seconds = 7385 से शुरू करें, और आउटपुट होना चाहिए:

2 h 3 m 5 s

तीन शर्तें:

1. सिर्फ़ // और % इस्तेमाल करें — कोई भी रिज़ल्ट हाथ से न लिखें
2. तीनों वैल्यू तीन अलग वेरिएबल में रखें, नाम मतलब वाले हों
3. फिर total_seconds की वैल्यू बदलकर 59, 60, 3600 और 86399 से चलाकर देखें — चारों में जवाब सही आ रहा है या नहीं

आखिरी स्टेप मत छोड़िए। प्रोग्राम एक इनपुट पर सही चले, इसका मतलब यह नहीं कि वह काम करता है; सीमा के पास की वैल्यू पर भी सही चले, तब वह काम करता है।