संख्याएँ और अंकगणित
संख्याएँ लगभग हर उस प्रोग्राम में दिखती हैं जो आप लिखते हैं। एक शॉपिंग कार्ट कीमत का कुल जोड़ता है। एक गेम स्कोर अपडेट करता है। एक स्क्रिप्ट गिनती करती है कि कोई चीज़ कितनी बार हुई। Python आपको ऐसे अंकगणितीय ऑपरेटर देता है जो कागज़ी गणित की तरह काम करते हैं, साथ ही कुछ और भी जो शुरुआत से ही जानने योग्य हैं।
ऑपरेटर्स
गणित के चार ऑपरेटर (+, -, *, /) ठीक उसी तरह काम करते हैं जैसा आप अपेक्षा करेंगे। Python तीन और जोड़ता है जिनका आप लगातार उपयोग करेंगे: पूर्णांक भाजन, शेषफल, और घात।
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 |
भाग: / बनाम //
/ आपको हमेशा सटीक दशमलव परिणाम देता है, भले ही उत्तर पूर्ण संख्या हो। // आपको केवल पूर्ण-संख्या भाग देता है, दशमलव बिंदु के बाद की सब कुछ काट देता है। यह राउंड नहीं करता; यह काटता है:
10 / 2 # 5.0 (हमेशा float, भले ही समान रूप से विभाजित हो)
10 / 3 # 3.3333333333333335
10 // 3 # 3
7 // 2 # 3
-7 // 2 # -4 (ऋणात्मक अनंत की ओर फ़्लोर करता है, शून्य की ओर नहीं)-7 // 2 का परिणाम लोगों को आश्चर्यचकित करता है। आप ज्यादातर // का उपयोग धनात्मक संख्याओं के साथ करेंगे जहाँ यह सामने नहीं आता। इसे अपने दिमाग के पीछे रखें जब ऋणात्मक संख्याएँ सामने आएँ।
शेषफल ऑपरेटर %
% आपको देता है जो पूर्णांक भाजन के बाद बचता है। यदि 10 // 3 3 है (क्योंकि 3, 10 में तीन बार जाता है), तो 10 % 3 1 है (क्योंकि 3 × 3 = 9, और 10 - 9 = 1)। सबसे आम उपयोग यह जाँचना है कि कोई संख्या सम है या विषम।
10 % 3 # 1
10 % 2 # 0 (समान रूप से विभाजित होता है)
10 % 7 # 3
6 % 2 # 0 (सम)
7 % 2 # 1 (विषम)घात **
** किसी संख्या को घात तक उठाता है। दो तारांकन का उपयोग करें, ^ प्रतीक का नहीं (जिसका Python में कुछ और अर्थ है):
2 ** 10 # 1024
3 ** 3 # 27
9 ** 0.5 # 3.0 (वर्गमूल: 0.5 की घात तक उठाएँ)ऑपरेटर प्रिसेडेंस
Python मानक गणित क्रम का पालन करता है: पहले घात, फिर गुणा और भाग, फिर जोड़ और घटाव। जब आप अनिश्चित हों, कोष्ठक का उपयोग करें। वे इरादे को स्पष्ट करते हैं और कुछ भी खर्च नहीं करते:
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.0int और float कैसे परस्पर क्रिया करते हैं
Python का एक सुसंगत नियम है: / हमेशा एक दशमलव लौटाता है (यहाँ तक कि 4 / 2 भी 2.0 देता है), और किसी पूर्णांक और दशमलव को मिलाने वाला कोई भी ऑपरेशन एक दशमलव देता है। जब आपको पूर्ण संख्या चाहिए, // का उपयोग करें या int() से रूपांतरित करें।
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)Float परिशुद्धता
एक गोत्चा है जो किसी न किसी बिंदु पर लगभग सभी को आश्चर्यचकित करता है:
0.1 + 0.2 # 0.30000000000000004वह छोटी सी त्रुटि कोई Python बग नहीं है। कंप्यूटर दशमलव संख्याओं को बाइनरी में संग्रहीत करते हैं, और 0.1 जैसे कुछ मान सटीक रूप से प्रस्तुत नहीं किए जा सकते। यह उसी तरह है जैसे 1/3 को दशमलव में सटीक रूप से नहीं लिखा जा सकता। अधिकांश रोज़मर्रा की गणनाओं के लिए यह मायने नहीं रखता। पैसे प्रदर्शित करने के लिए, round() या :.2f फ़ॉर्मेट स्पेसिफ़ायर आउटपुट को साफ़-सुथरा रखेगा।
पठनीय संख्या लिटरल्स
Python आपको बड़ी संख्याओं को पढ़ने में आसान बनाने के लिए संख्या लिटरल्स में अंडरस्कोर रखने देता है। Python उन्हें पूरी तरह से अनदेखा कर देता है; वे केवल आपके लिए हैं:
population = 8_100_000_000
distance_km = 384_400
pi_approx = 3.141_592_653उपयोगी बिल्ट-इन फ़ंक्शन्स
abs()
abs() निरपेक्ष मान लौटाता है: इनपुट के चिह्न की परवाह किए बिना हमेशा धनात्मक। इसका उपयोग तब करें जब आप परवाह करते हैं कि कोई संख्या शून्य से कितनी दूर है, न कि किस दिशा में।
abs(-5) # 5
abs(3.7) # 3.7
abs(-0.5) # 0.5round()
round() डिफ़ॉल्ट रूप से निकटतम पूर्णांक तक राउंड करता है। दशमलव स्थानों की विशिष्ट संख्या रखने के लिए दूसरा तर्क पास करें:
round(3.7) # 4
round(3.2) # 3
round(3.14159, 2) # 3.14एक बात जानने लायक है: round(2.5) 3 नहीं, 2 देता है। जब मान दो विकल्पों के ठीक बीच में होता है तो Python निकटतम सम संख्या तक राउंड करता है।
divmod()
divmod() आपको एक ही कॉल में भागफल और शेषफल दोनों देता है। यह मानों की एक जोड़ी लौटाता है जिसे आप एक साथ दो नामों को असाइन कर सकते हैं:
divmod(10, 3) # (3, 1): भागफल 3, शेषफल 1
divmod(7, 2) # (3, 1)
divmod(9, 3) # (3, 0)
quotient, remainder = divmod(10, 3)
print(quotient) # 3
print(remainder) # 1(3, 1) वाली चीज़ क्या है?
यह एक tuple है: एक साथ लौटाए गए मानों की एक निश्चित जोड़ी। Tuples का अपना अध्याय है। फ़िलहाल, ऊपर दिखाए अनुसार एक साथ दो नामों को असाइन करके दोनों मानों को अलग करें।
व्यवहार में
एक टिप कैलकुलेटर:
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() आउटपुट को दशमलव स्थानों की लंबी पंक्ति के बजाय पैसे जैसा दिखाता रखता है।