Python Language
सरल गणितीय संचालक

परिचय

टिप्पणियों

इसके अलावा

a, b = 1, 2

# Using the "+" operator:
a + b                  # = 3

# Using the "in-place" "+=" operator to add and assign:
a += b                 # a = 3 (equivalent to a = a + b)

import operator        # contains 2 argument arithmetic functions for the examples

operator.add(a, b)     # = 5  since a is set to 3 right before this line

# The "+=" operator is equivalent to: 
a = operator.iadd(a, b)    # a = 5 since a is set to 3 right before this line

संभावित संयोजन (बिलिन प्रकार):

• int और int (एक int देता है)
• int और float (एक देता float )
• int और complex (एक complex देता है)
• float और float (एक देता float )
• float और complex (एक complex देता है)
• complex और complex (एक complex देता है)

नोट: + ऑपरेटर का उपयोग स्ट्रिंग्स, सूचियों और टुपल्स को जोड़ने के लिए भी किया जाता है:

"first string " + "second string"    # = 'first string second string'

[1, 2, 3] + [4, 5, 6]                # = [1, 2, 3, 4, 5, 6]

घटाव

a, b = 1, 2

# Using the "-" operator:
b - a                  # = 1


import operator        # contains 2 argument arithmetic functions
operator.sub(b, a)     # = 1

संभावित संयोजन (बिलिन प्रकार):

• int और int (एक int देता है)
• int और float (एक देता float )
• int और complex (एक complex देता है)
• float और float (एक देता float )
• float और complex (एक complex देता है)
• complex और complex (एक complex देता है)

गुणन

a, b = 2, 3

a * b                  # = 6

import operator
operator.mul(a, b)     # = 6

संभावित संयोजन (बिलिन प्रकार):

• int और int (एक int देता है)
• int और float (एक देता float )
• int और complex (एक complex देता है)
• float और float (एक देता float )
• float और complex (एक complex देता है)
• complex और complex (एक complex देता है)

नोट: * ऑपरेटर का उपयोग स्ट्रिंग्स, सूचियों और टुपल्स के दोहराए जाने के लिए भी किया जाता है:

3 * 'ab'  # = 'ababab'
3 * ('a', 'b')  # = ('a', 'b', 'a', 'b', 'a', 'b')

विभाजन

जब दोनों ऑपरेंड पूर्णांक होते हैं तो पायथन पूर्णांक विभाजन करता है। पायथन के डिवीजन ऑपरेटरों का व्यवहार पायथन 2.x और 3.x ( इंटेगर डिवीजन भी देखें) से बदल गया है।

a, b, c, d, e = 3, 2, 2.0, -3, 10

a / b                  # = 1 

a / c                  # = 1.5

d / b                  # = -2

b / a                  # = 0

d / e                  # = -1

import operator        # the operator module provides 2-argument arithmetic functions
operator.div(a, b)     # = 1
operator.__div__(a, b) # = 1

from __future__ import division # applies Python 3 style division to the entire module
a / b                  # = 1.5 
a // b                 # = 1

a / (b * 1.0)          # = 1.5
1.0 * a / b            # = 1.5
a / b * 1.0            # = 1.0    (careful with order of operations)

from operator import truediv
truediv(a, b)          # = 1.5

float(a) / b           # = 1.5
a / float(b)           # = 1.5

a // b                # = 1
a // c                # = 1.0

a / b                  # = 1.5 
e / b                  # = 5.0
a // b                 # = 1
a // c                 # = 1.0

import operator            # the operator module provides 2-argument arithmetic functions
operator.truediv(a, b)     # = 1.5
operator.floordiv(a, b)    # = 1
operator.floordiv(a, c)    # = 1.0

संभावित संयोजन (बिलिन प्रकार):

• int और int (Python 2 में एक int देता है और Python 3 में एक float )
• int और float (एक देता float )
• int और complex (एक complex देता है)
• float और float (एक देता float )
• float और complex (एक complex देता है)
• complex और complex (एक complex देता है)

अधिक जानकारी के लिए PEP 238 देखें।

Exponentation

a, b = 2, 3

(a ** b)               # = 8
pow(a, b)              # = 8

import math
math.pow(a, b)         # = 8.0 (always float; does not allow complex results)

import operator
operator.pow(a, b)     # = 8

बीच एक और अंतर में निर्मित pow और math.pow है कि निर्मित pow तीन तर्कों को स्वीकार कर सकते हैं:

a, b, c = 2, 3, 2

pow(2, 3, 2)           # 0, calculates (2 ** 3) % 2, but as per Python docs,
                       #    does so more efficiently

विशेष कार्य

समारोह math.sqrt(x) का वर्गमूल गणना करता है x ।

import math
import cmath
c = 4
math.sqrt(c)           # = 2.0 (always float; does not allow complex results)
cmath.sqrt(c)          # = (2+0j) (always complex)

अन्य जड़ों की गणना करने के लिए, जैसे कि क्यूब रूट, संख्या को रूट की डिग्री के पारस्परिक तक बढ़ाएं। यह किसी भी घातीय कार्य या ऑपरेटर के साथ किया जा सकता है।

 import math
 x = 8
 math.pow(x, 1/3) # evaluates to 2.0
 x**(1/3) # evaluates to 2.0

फ़ंक्शन math.exp(x) e ** x गणना करता है।

math.exp(0)  # 1.0
math.exp(1)  # 2.718281828459045 (e)

फ़ंक्शन math.expm1(x) e ** x - 1 गणना करता है। जब x छोटा होता है, तो यह math.exp(x) - 1 तुलना में काफी बेहतर सटीकता देता है।

math.expm1(0)       # 0.0

math.exp(1e-6) - 1  # 1.0000004999621837e-06
math.expm1(1e-6)    # 1.0000005000001665e-06
# exact result      # 1.000000500000166666708333341666...

लघुगणक

डिफ़ॉल्ट रूप से, math.log फ़ंक्शन किसी संख्या, बेस ई के लघुगणक की गणना करता है। आप वैकल्पिक रूप से दूसरे तर्क के रूप में एक आधार निर्दिष्ट कर सकते हैं।

import math
import cmath

math.log(5)         # = 1.6094379124341003
# optional base argument. Default is math.e
math.log(5, math.e) # = 1.6094379124341003
cmath.log(5)        # = (1.6094379124341003+0j)
math.log(1000, 10)   # 3.0 (always returns float)
cmath.log(1000, 10)  # (3+0j)

math.log फ़ंक्शन की विशेष विविधताएँ विभिन्न आधारों के लिए मौजूद हैं।

# Logarithm base e - 1 (higher precision for low values)
math.log1p(5)       # = 1.791759469228055

# Logarithm base 2
math.log2(8)        # = 3.0

# Logarithm base 10
math.log10(100)     # = 2.0
cmath.log10(100)    # = (2+0j)

Inplace Operation

एप्लिकेशन के भीतर इस तरह कोड होना आम है:

a = a + 1

या

a = a * 2

स्थान संचालन में इनके लिए एक प्रभावी शॉर्टकट है:

a += 1
# and
a *= 2

किसी भी गणितीय संचालक का उपयोग '=' वर्ण से पहले किया जा सकता है ताकि वह एक इनकम ऑपरेशन कर सके:

• -= जगह में चर को कम करना
• += स्थान में परिवर्तनशील वृद्धि
• *= जगह में चर को गुणा करें
• /= चर को जगह में विभाजित करें
• //= मंजिल चर को # पायथन 3 में विभाजित करती है
• %= चर के मापांक को वापस लौटाएं
• **= जगह में एक शक्ति के लिए बढ़ा

जगह ऑपरेटरों में अन्य बिटवाइज़ ऑपरेटर्स के लिए मौजूद हैं ( ^ , | आदि)

त्रिकोणमितीय फलन

a, b = 1, 2

import math

math.sin(a)  # returns the sine of 'a' in radians
# Out: 0.8414709848078965

math.cosh(b)  # returns the inverse hyperbolic cosine of 'b' in radians
# Out: 3.7621956910836314

math.atan(math.pi)  # returns the arc tangent of 'pi' in radians
# Out: 1.2626272556789115

math.hypot(a, b) # returns the Euclidean norm, same as math.sqrt(a*a + b*b)
# Out: 2.23606797749979

ध्यान दें कि math.hypot(x, y) भी मूल (0, 0) से बिंदु (x, y) तक वेक्टर (या यूक्लिडियन दूरी) की लंबाई है।

यूक्लिडियन दूरी की गणना दो बिंदुओं (x1, y1) और (x2, y2) आप math.hypot उपयोग इस प्रकार कर सकते हैं।

math.hypot(x2-x1, y2-y1)

रेडियन से परिवर्तित करने के लिए -> डिग्री और डिग्री -> रेडियन क्रमशः math.degrees और math.radians उपयोग करते हैं

math.degrees(a)
# Out: 57.29577951308232

math.radians(57.29577951308232)
# Out: 1.0

मापांक

कई अन्य भाषाओं की तरह, पायथन मापांक की गणना के लिए % ऑपरेटर का उपयोग करता है।

3 % 4     # 3
10 % 2    # 0
6 % 4     # 2

या operator मॉड्यूल का उपयोग करके:

import operator

operator.mod(3 , 4)     # 3
operator.mod(10 , 2)    # 0
operator.mod(6 , 4)     # 2

आप नकारात्मक संख्याओं का भी उपयोग कर सकते हैं।

-9 % 7     # 5
9 % -7     # -5
-9 % -7    # -2

यदि आपको पूर्णांक विभाजन और मापांक के परिणाम खोजने की आवश्यकता है, तो आप शॉर्टकट के रूप में divmod फ़ंक्शन का उपयोग कर सकते हैं:

quotient, remainder = divmod(9, 4)
# quotient = 2, remainder = 1 as 4 * 2 + 1 == 9