పైథాన్‌లో ఎక్స్‌పోనెన్షియల్ మరియు లాగరిథమిక్ ఫంక్షన్‌లను గణించండి (exp, log, log10, log2)

వ్యాపారం

గణితాన్ని ఉపయోగించి, గణిత విధుల కోసం పైథాన్ యొక్క ప్రామాణిక మాడ్యూల్, మీరు ఎక్స్‌పోనెన్షియల్ మరియు లాగరిథమిక్ ఫంక్షన్‌లను (సహజ సంవర్గమానం, సాధారణ సంవర్గమానం మరియు బైనరీ సంవర్గమానం) లెక్కించవచ్చు.

నమూనా కోడ్‌తో పాటు క్రిందివి ఇక్కడ వివరించబడ్డాయి.

  • సహజ సంవర్గమానం యొక్క ఆధారం (నేపియర్ సంఖ్య):math.e
  • శక్తి::**ఆపరేటర్,pow(),math.pow()
  • స్క్వేర్ రూట్ (రూట్):math.sqrt()
  • ఎక్స్‌పోనెన్షియల్ ఫంక్షన్ (సహజ ఘాతాంక విధి):math.exp()
  • ఒక లాగరిథమిక్ ఫంక్షన్:math.log(),math.log10(),math.log2()

సహజ సంవర్గమానం యొక్క ఆధారం (నేపియర్ సంఖ్య):math.e

సహజ సంవర్గమానం (నేపియర్ సంఖ్య) యొక్క ఆధారం గణిత మాడ్యూల్‌లో స్థిరంగా అందించబడుతుంది, ఇది math.e ద్వారా సూచించబడుతుంది.

import math

print(math.e)
# 2.718281828459045

శక్తి: ** ఆపరేటర్, పౌ(), math.pow():**ఆపరేటర్,pow(),math.pow()

అధికారాలను గణించడానికి, ** ఆపరేటర్, అంతర్నిర్మిత ఫంక్షన్ pow(), లేదా math.pow()ని ఉపయోగించండి.

x యొక్క y-స్క్వేర్ క్రింది విధంగా పొందబడింది

  • x**y
  • pow(x, y)
  • math.pow(x, y)
print(2**4)
# 16

print(pow(2, 4))
# 16

print(math.pow(2, 4))
# 16.0

math.pow() ఆర్గ్యుమెంట్‌ను ఫ్లోటింగ్ పాయింట్ రకానికి మారుస్తుంది. మరోవైపు, పైథాన్ యొక్క అంతర్నిర్మిత ఫంక్షన్ పౌ() ప్రతి రకానికి నిర్వచించబడిన __pow()__ని ఉపయోగిస్తుంది.

ఉదాహరణకు, pow() సంక్లిష్ట రకాలను ఆర్గ్యుమెంట్‌లుగా పేర్కొనడానికి అనుమతిస్తుంది, కానీ math.pow() సంక్లిష్ట రకాలను ఫ్లోట్ రకాలుగా మార్చదు, ఫలితంగా లోపం ఏర్పడుతుంది.

print(pow(1 + 1j, 2))
# 2j

# print(math.pow(1 + 1j, 2))
# TypeError: can't convert complex to float

పైథాన్ అంతర్నిర్మిత ఫంక్షన్ pow() మూడవ ఆర్గ్యుమెంట్, pow(x, y, z)ని కూడా అనుమతిస్తుంది, ఇది z యొక్క మిగిలిన (మిగిలినది)ని x యొక్క y-పవర్‌కి అందిస్తుంది. ఇది పౌ(x, y) % z వలె అదే గణన, కానీ పౌ(x, y, z) మరింత ప్రభావవంతంగా ఉంటుంది.

print(pow(2, 4, 5))
# 1

స్క్వేర్ రూట్ (రూట్):math.sqrt()

వర్గమూలాన్ని (రూట్) ** లేదా math.sqrt() ఉపయోగించి **0.5కి సెట్ చేయవచ్చు.

print(2**0.5)
# 1.4142135623730951

print(math.sqrt(2))
# 1.4142135623730951

print(2**0.5 == math.sqrt(2))
# True

math.pow(), math.sqrt() లాగా ప్రాసెసింగ్ కోసం ఆర్గ్యుమెంట్‌లను ఫ్లోటింగ్ పాయింట్ రకాలుగా మారుస్తుంది, కాబట్టి ఫ్లోట్ రకానికి మార్చలేని రకాన్ని పేర్కొనడం వలన TypeError వస్తుంది.

print((-3 + 4j)**0.5)
# (1.0000000000000002+2j)

# print(math.sqrt(-3 + 4j))
# TypeError: can't convert complex to float

అలాగే, math.sqrt() ప్రతికూల విలువలను ప్రాసెస్ చేయదు, ఫలితంగా ValueError ఏర్పడుతుంది.

print((-1)**0.5)
# (6.123233995736766e-17+1j)

# print(math.sqrt(-1))
# ValueError: math domain error

సంక్లిష్ట సంఖ్యలతో వ్యవహరించేటప్పుడు, ** ఆపరేటర్‌ని ఉపయోగించే ఉదాహరణ లోపాన్ని చూపుతుందని గమనించండి, అయితే cmath మాడ్యూల్ మరింత ఖచ్చితమైన విలువను అందిస్తుంది. ప్రతికూల విలువలను కూడా నిర్వహించవచ్చు.

import cmath

print(cmath.sqrt(-3 + 4j))
# (1+2j)

print(cmath.sqrt(-1))
# 1j

ఎక్స్‌పోనెన్షియల్ ఫంక్షన్ (సహజ ఘాతాంక విధి):math.exp()

సహజ సంవర్గమానం (నేపియర్ సంఖ్య) యొక్క ఆధారం యొక్క శక్తిని గణించడానికి, math.exp()ని ఉపయోగించండి.

math.exp(x) x స్క్వేర్డ్ ఆఫ్ ఇ.
math.exp(x) అనేది “math.e ** x”కి సమానం కాదు మరియు math.exp(x) మరింత ఖచ్చితమైనది.

print(math.exp(2))
# 7.38905609893065

print(math.exp(2) == math.e**2)
# False

ఒక లాగరిథమిక్ ఫంక్షన్:math.log(),math.log10(),math.log2()

లాగరిథమిక్ ఫంక్షన్‌ను గణించడానికి, math.log(),math.log10(),math.log2()ని ఉపయోగించండి.

math.log(x, y) x యొక్క లాగరిథమ్‌ని yతో బేస్‌గా అందిస్తుంది.

print(math.log(25, 5))
# 2.0

రెండవ వాదన విస్మరించబడితే, సహజ సంవర్గమానం క్రింద చూపబడుతుంది.

సంవర్గమానం

గణితశాస్త్రంలో, లాగ్ లేదా ln ద్వారా ప్రాతినిధ్యం వహించే సహజ సంవర్గమానం (నేపియర్ సంఖ్య e ఆధారంగా సంవర్గమానం), math.log(x) ద్వారా లెక్కించబడుతుంది.

print(math.log(math.e))
# 1.0

సంవర్గమానం (బేస్ 10)

సాధారణ సంవర్గమానం (బేస్ 10తో సంవర్గమానం) math.log10(x)తో లెక్కించబడుతుంది, ఇది math.log(x, 10) కంటే చాలా ఖచ్చితమైనది.

print(math.log10(100000))
# 5.0

బైనరీ సంవర్గమానం

బైనరీ సంవర్గమానం (బేస్ 2తో సంవర్గమానం) math.log2(x)తో లెక్కించబడుతుంది, ఇది math.log(x, 2) కంటే మరింత ఖచ్చితమైనది.

print(math.log2(1024))
# 10.0