గణిత విధుల కోసం పైథాన్ యొక్క ప్రామాణిక మాడ్యూల్ అయిన గణితాన్ని ఉపయోగించి, మీరు త్రికోణమితి ఫంక్షన్‌లను (సిన్, కాస్, టాన్) మరియు విలోమ త్రికోణమితి ఫంక్షన్‌లను (ఆర్క్‌సిన్, ఆర్కోస్, ఆర్క్టాన్) లెక్కించవచ్చు.
కింది విషయాలు నమూనా కోడ్‌లతో ఇక్కడ వివరించబడ్డాయి.
- పై (3.1415926..):
math.pi - కోణ మార్పిడి (రేడియన్లు, డిగ్రీలు):
math.degrees(),math.radians() - సైన్, ఇన్వర్స్ సైన్:
math.sin(),math.asin() - కొసైన్, విలోమ కొసైన్:
math.cos(),math.acos() - టాంజెంట్, విలోమ టాంజెంట్:
math.tan(),math.atan(),math.atan2() - క్రింద తేడాలు:
math.atan(),math.atan2()
పై (3.1415926..):math.pi
గణిత మాడ్యూల్‌లో Pi స్థిరంగా అందించబడుతుంది. ఇది క్రింది విధంగా వ్యక్తీకరించబడింది.math.pi
import math
print(math.pi)
# 3.141592653589793
కోణ మార్పిడి (రేడియన్లు, డిగ్రీలు):math.degrees(),math.radians()
గణిత మాడ్యూల్‌లోని త్రికోణమితి మరియు విలోమ త్రికోణమితి విధులు రేడియన్‌ను కోణం యొక్క యూనిట్‌గా ఉపయోగిస్తాయి.
రేడియన్స్ (ఆర్క్ డిగ్రీ పద్ధతి) మరియు డిగ్రీల (డిగ్రీ పద్ధతి) మధ్య మార్చడానికి math.degrees() మరియు math.radians() ఉపయోగించండి.
Math.degrees() రేడియన్స్ నుండి డిగ్రీలకి మారుతుంది మరియు math.radians() డిగ్రీలు నుండి రేడియన్స్‌కి మారుస్తుంది.
print(math.degrees(math.pi))
# 180.0
print(math.radians(180))
# 3.141592653589793
సైన్, ఇన్వర్స్ సైన్:math.sin(),math.asin()
సైన్ (పాపం)ని కనుగొనే ఫంక్షన్ math.sin() మరియు విలోమ సైన్ (arcsin)ని కనుగొనే ఫంక్షన్ math.asin().
డిగ్రీలను రేడియన్‌లుగా మార్చడానికి math.radians()ని ఉపయోగించి 30 డిగ్రీల సైన్‌ని కనుగొనే ఉదాహరణ ఇక్కడ ఉంది.
sin30 = math.sin(math.radians(30))
print(sin30)
# 0.49999999999999994
30 డిగ్రీల సైన్ 0.5, కానీ ఒక అహేతుక సంఖ్య అయిన pi, ఖచ్చితంగా గణించబడనందున ఒక లోపం ఉంది.
మీరు తగిన సంఖ్యలో అంకెలకు రౌండ్ చేయాలనుకుంటే, రౌండ్() ఫంక్షన్ లేదా ఫార్మాట్() పద్ధతి లేదా ఫార్మాట్() ఫంక్షన్‌ని ఉపయోగించండి.
రౌండ్() యొక్క రిటర్న్ విలువ ఒక సంఖ్య (పూర్ణాంక లేదా ఫ్లోట్) అని గమనించండి, అయితే ఫార్మాట్() యొక్క రిటర్న్ విలువ స్ట్రింగ్. మీరు తదుపరి గణనల కోసం దీన్ని ఉపయోగించాలనుకుంటే, రౌండ్() ఉపయోగించండి.
print(round(sin30, 3))
print(type(round(sin30, 3)))
# 0.5
# <class 'float'>
print('{:.3}'.format(sin30))
print(type('{:.3}'.format(sin30)))
# 0.5
# <class 'str'>
print(format(sin30, '.3'))
print(type(format(sin30, '.3')))
# 0.5
# <class 'str'>
రౌండ్() ఫంక్షన్ దాని రెండవ ఆర్గ్యుమెంట్‌గా దశాంశ స్థానాల సంఖ్యను నిర్దేశిస్తుంది. ఇది ఖచ్చితంగా చుట్టుముట్టడం లేదని గమనించండి. వివరాల కోసం క్రింది కథనాన్ని చూడండి.
ఫార్మాట్() పద్ధతి మరియు ఫార్మాట్() ఫంక్షన్ ఫార్మాటింగ్ స్పెసిఫికేషన్ స్ట్రింగ్‌లోని దశాంశ స్థానాల సంఖ్యను పేర్కొంటాయి. వివరాల కోసం క్రింది కథనాన్ని చూడండి.
మీరు సరిపోల్చాలనుకుంటే, మీరు math.isclose()ని కూడా ఉపయోగించవచ్చు.
print(math.isclose(sin30, 0.5))
# True
అదేవిధంగా, 0.5 యొక్క విలోమ సైన్‌ను కనుగొనే ఉదాహరణ ఇక్కడ ఉంది. math.asin() రేడియన్‌లను అందిస్తుంది, ఇవి math.degrees()తో డిగ్రీలుగా మార్చబడతాయి.
asin05 = math.degrees(math.asin(0.5))
print(asin05)
# 29.999999999999996
print(round(asin05, 3))
# 30.0
కొసైన్, విలోమ కొసైన్:math.cos(),math.acos()
కొసైన్ (cos)ని కనుగొనే ఫంక్షన్ math.cos(), మరియు విలోమ కొసైన్ (ఆర్క్ కొసైన్, ఆర్కోస్)ని కనుగొనే ఫంక్షన్ math.acos().
60 డిగ్రీల కొసైన్‌ను మరియు 0.5 విలోమ కొసైన్‌ను కనుగొనే ఉదాహరణ ఇక్కడ ఉంది.
print(math.cos(math.radians(60)))
# 0.5000000000000001
print(math.degrees(math.acos(0.5)))
# 59.99999999999999
మీరు తగిన అంకెకు రౌండ్ చేయాలనుకుంటే, మీరు రౌండ్() లేదా ఫార్మాట్()ని సైన్తో ఉపయోగించవచ్చు.
టాంజెంట్, విలోమ టాంజెంట్:math.tan(),math.atan(),math.atan2()
టాంజెంట్ (టాన్)ని కనుగొనే ఫంక్షన్ math.tan(), మరియు విలోమ టాంజెంట్ (arctan)ని కనుగొనే ఫంక్షన్ math.atan() లేదా math.atan2().
Math.atan2() తరువాత వివరించబడింది.
45 డిగ్రీల టాంజెంట్ మరియు 1 డిగ్రీ యొక్క విలోమ టాంజెంట్‌ని కనుగొనే ఉదాహరణ క్రింద చూపబడింది.
print(math.tan(math.radians(45)))
# 0.9999999999999999
print(math.degrees(math.atan(1)))
# 45.0
math.atan() మరియు math.atan2() మధ్య వ్యత్యాసం
math.atan() మరియు math.atan2() రెండూ విలోమ టాంజెంట్‌ని అందించే ఫంక్షన్‌లు, అయితే అవి ఆర్గ్యుమెంట్‌ల సంఖ్య మరియు రిటర్న్ విలువల పరిధిలో విభిన్నంగా ఉంటాయి.
math.atan(x)కి ఒక ఆర్గ్యుమెంట్ ఉంది మరియు రేడియన్‌లలో ఆర్క్టాన్(x)ని అందిస్తుంది. తిరిగి వచ్చే విలువ -pi \ 2 మరియు pi \ 2 (-90 నుండి 90 డిగ్రీలు) మధ్య ఉంటుంది.
print(math.degrees(math.atan(0)))
# 0.0
print(math.degrees(math.atan(1)))
# 45.0
print(math.degrees(math.atan(-1)))
# -45.0
print(math.degrees(math.atan(math.inf)))
# 90.0
print(math.degrees(math.atan(-math.inf)))
# -90.0
పై ఉదాహరణలో, math.inf అనంతాన్ని సూచిస్తుంది.
math.atan2(y, x)కి రెండు ఆర్గ్యుమెంట్‌లు ఉన్నాయి మరియు రేడియన్‌లలో ఆర్క్టాన్(y \ x)ని అందిస్తుంది. ఈ కోణం అనేది మూలం నుండి కోఆర్డినేట్‌ల వరకు వెక్టర్ (x, y) ధ్రువ కోఆర్డినేట్ ప్లేన్‌లోని x అక్షం యొక్క సానుకూల దిశతో చేసే కోణం (క్షీణత), మరియు తిరిగి వచ్చిన విలువ -pi మరియు pi (-180) మధ్య ఉంటుంది. 180 డిగ్రీల వరకు).
రెండవ మరియు మూడవ క్వాడ్రాంట్‌లలోని కోణాలను కూడా సరిగ్గా పొందవచ్చు కాబట్టి, ధ్రువ సమన్వయ సమతలాన్ని పరిగణనలోకి తీసుకునేటప్పుడు math.atan() కంటే math.atan2() సరైనది.
ఆర్గ్యుమెంట్‌ల క్రమం y, x, x, y కాదు అని గమనించండి.
print(math.degrees(math.atan2(0, 1)))
# 0.0
print(math.degrees(math.atan2(1, 1)))
# 45.0
print(math.degrees(math.atan2(1, 0)))
# 90.0
print(math.degrees(math.atan2(1, -1)))
# 135.0
print(math.degrees(math.atan2(0, -1)))
# 180.0
print(math.degrees(math.atan2(-1, -1)))
# -135.0
print(math.degrees(math.atan2(-1, 0)))
# -90.0
print(math.degrees(math.atan2(-1, 1)))
# -45.0
పై ఉదాహరణలో వలె, x-అక్షం యొక్క ప్రతికూల దిశ (y సున్నా మరియు x ప్రతికూలం) pi (180 డిగ్రీలు), కానీ y ప్రతికూల సున్నా అయినప్పుడు, అది -pi (-180 డిగ్రీలు). మీరు గుర్తును ఖచ్చితంగా నిర్వహించాలనుకుంటే జాగ్రత్తగా ఉండండి.
print(math.degrees(math.atan2(-0.0, -1)))
# -180.0
ప్రతికూల సున్నాలు క్రింది కార్యకలాపాల ఫలితం
print(-1 / math.inf)
# -0.0
print(-1.0 * 0.0)
# -0.0
పూర్ణాంకాలు ప్రతికూల సున్నాలుగా పరిగణించబడవు.
print(-0.0)
# -0.0
print(-0)
# 0
x మరియు y రెండూ సున్నా అయినప్పటికీ, ఫలితం గుర్తుపై ఆధారపడి ఉంటుంది.
print(math.degrees(math.atan2(0.0, 0.0)))
# 0.0
print(math.degrees(math.atan2(-0.0, 0.0)))
# -0.0
print(math.degrees(math.atan2(-0.0, -0.0)))
# -180.0
print(math.degrees(math.atan2(0.0, -0.0)))
# 180.0
math.atan2() అలాగే math.sin(), math.asin(), math.tan(), మరియు math.atan() వంటి ప్రతికూల సున్నాలపై ఆధారపడి ఫలితం యొక్క సంకేతం మారే ఇతర ఉదాహరణలు ఉన్నాయి. .
print(math.sin(0.0))
# 0.0
print(math.sin(-0.0))
# -0.0
print(math.asin(0.0))
# 0.0
print(math.asin(-0.0))
# -0.0
print(math.tan(0.0))
# 0.0
print(math.tan(-0.0))
# -0.0
print(math.atan(0.0))
# 0.0
print(math.atan(-0.0))
# -0.0
print(math.atan2(0.0, 1.0))
# 0.0
print(math.atan2(-0.0, 1.0))
# -0.0
ఇప్పటివరకు ఉన్న ఉదాహరణలు CPythonలో ప్రోగ్రామ్‌ను అమలు చేయడం వల్ల వచ్చిన ఫలితాలు అని గమనించండి. ఇతర అమలులు లేదా పర్యావరణాలు ప్రతికూల సున్నాలను భిన్నంగా నిర్వహించవచ్చని గమనించండి.
