పైథాన్, సంక్లిష్ట సంఖ్యలతో పని చేయడానికి సంక్లిష్ట రకాలు (సంపూర్ణ విలువలు, క్షీణత, ధ్రువ పరివర్తనాలు మొదలైనవి)

వ్యాపారం

సంక్లిష్ట సంఖ్యలను నిర్వహించడానికి పైథాన్ ప్రామాణిక రకాన్ని కలిగి ఉంది, కాంప్లెక్స్ రకం. మీరు సాధారణ గణనలను చేయాలనుకుంటే, మీరు ఏ మాడ్యూల్‌లను దిగుమతి చేయనవసరం లేదు, కానీ మీరు ప్రామాణిక లైబ్రరీ cmathని దిగుమతి చేస్తే, మీరు సంక్లిష్ట సంఖ్యలకు సంబంధించిన గణిత విధులను (ఘాతాంక, సంవర్గమాన, త్రికోణమితి, మొదలైనవి) కూడా ఉపయోగించవచ్చు.

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

  • సంక్లిష్ట వేరియబుల్స్‌ను రూపొందించండి
  • నిజమైన మరియు ఊహాత్మక భాగాలను పొందండి:real,imagగుణం
  • సంయోగ సంక్లిష్ట సంఖ్యలను పొందండి:conjugate()పద్ధతి
  • సంపూర్ణ విలువను పొందండి (పరిమాణం):abs()ఫంక్షన్ (ఉదా. గణితం, ప్రోగ్రామింగ్, ప్రోగ్రామింగ్)
  • క్షీణతను పొందండి (దశ):math,cmathమాడ్యూల్
  • పోలార్ కోఆర్డినేట్ ట్రాన్స్‌ఫర్మేషన్ (ధ్రువ రూప ప్రాతినిధ్యం):math,cmathమాడ్యూల్
  • సంక్లిష్ట సంఖ్యల గణన (చతుర్భుజం, శక్తులు, వర్గమూలాలు)

సంక్లిష్ట వేరియబుల్స్‌ను రూపొందించండి

ఊహాత్మక యూనిట్‌ని j ద్వారా సూచించండి మరియు కింది వాటిని వ్రాయండి, అది i కాదని గమనించండి.

c = 3 + 4j

print(c)
print(type(c))
# (3+4j)
# <class 'complex'>

ఊహాత్మక భాగం 1 అయితే, దానిని వదిలివేయడం వలన పేరులో లోపం ఏర్పడుతుంది. j అనే వేరియబుల్ ముందుగా నిర్వచించబడితే, అది ఆ వేరియబుల్‌గా పరిగణించబడుతుంది.

1j
ఈ విధంగా స్పష్టంగా చెప్పాలి.

# c = 3 + j
# NameError: name 'j' is not defined

c = 3 + 1j

print(c)
# (3+1j)

నిజమైన భాగం 0 అయితే, దానిని విస్మరించవచ్చు.

c = 3j

print(c)
# 3j

మీరు 0 యొక్క ఊహాత్మక భాగంతో కూడిన విలువను సంక్లిష్ట సంక్లిష్ట రకంగా నిర్వచించాలనుకుంటే, 0ని స్పష్టంగా వ్రాయండి. దిగువ వివరించిన విధంగా, సంక్లిష్ట రకం మరియు పూర్ణాంకం రకం లేదా ఫ్లోటింగ్-పాయింట్ రకం మధ్య కార్యకలాపాలు నిర్వహించబడతాయి.

c = 3 + 0j

print(c)
# (3+0j)

వాస్తవ మరియు ఊహాత్మక భాగాలను ఫ్లోటింగ్ పాయింట్ ఫ్లోట్ రకంగా పేర్కొనవచ్చు. ఘాతాంక సంజ్ఞామానం కూడా ఆమోదయోగ్యమైనది.

c = 1.2e3 + 3j

print(c)
# (1200+3j)

ఇది “కాంప్లెక్స్ (వాస్తవ భాగం, ఊహాత్మక భాగం)” వలె “కాంప్లెక్స్” రకం యొక్క కన్స్ట్రక్టర్ ద్వారా కూడా రూపొందించబడుతుంది.

c = complex(3, 4)

print(c)
print(type(c))
# (3+4j)
# <class 'complex'>

సంక్లిష్ట సంఖ్యల వాస్తవ మరియు ఊహాత్మక భాగాలను పొందండి:real,imagగుణం

సంక్లిష్ట సంక్లిష్ట రకం యొక్క నిజమైన మరియు ఊహాత్మక భాగాలను వరుసగా నిజమైన మరియు ఇమేజ్ లక్షణాలతో పొందవచ్చు. రెండూ ఫ్లోటింగ్ పాయింట్ ఫ్లోట్ రకాలు.

c = 3 + 4j

print(c.real)
print(type(c.real))
# 3.0
# <class 'float'>

print(c.imag)
print(type(c.imag))
# 4.0
# <class 'float'>

ఇది చదవడానికి మాత్రమే మరియు మార్చబడదు.

# c.real = 5.5
# AttributeError: readonly attribute

సంయోగ సంక్లిష్ట సంఖ్యలను పొందండి:conjugate()

సంయోగ సంక్లిష్ట సంఖ్యలను పొందేందుకు, సంయోగం() పద్ధతిని ఉపయోగించండి.

c = 3 + 4j

print(c.conjugate())
# (3-4j)

సంక్లిష్ట సంఖ్య యొక్క సంపూర్ణ విలువ (పరిమాణం) పొందండి:abs()

సంక్లిష్ట సంఖ్య యొక్క సంపూర్ణ విలువ (పరిమాణం) పొందేందుకు, అంతర్నిర్మిత ఫంక్షన్ abs()ని ఉపయోగించండి.

c = 3 + 4j

print(abs(c))
# 5.0

c = 1 + 1j

print(abs(c))
# 1.4142135623730951

సంక్లిష్ట సంఖ్య యొక్క క్షీణతను (దశ) పొందండి:math,cmathమాడ్యూల్

సంక్లిష్ట సంఖ్య యొక్క క్షీణతను (దశ) పొందేందుకు, గణితం లేదా cmath మాడ్యూల్ ఉపయోగించండి.

cmath మాడ్యూల్ అనేది సంక్లిష్ట సంఖ్యల కోసం ఒక గణిత ఫంక్షన్ మాడ్యూల్.

దీనిని నిర్వచించిన విధంగా విలోమ టాంజెంట్ ఫంక్షన్ math.atan2()తో గణించవచ్చు లేదా క్షీణతను (దశ) తిరిగి ఇచ్చే cmath.phase()ని ఉపయోగించవచ్చు.

import cmath
import math

c = 1 + 1j

print(math.atan2(c.imag, c.real))
# 0.7853981633974483

print(cmath.phase(c))
# 0.7853981633974483

print(cmath.phase(c) == math.atan2(c.imag, c.real))
# True

రెండు సందర్భాల్లోనూ, రేడియన్‌లు పొందగలిగే కోణం యూనిట్. డిగ్రీలకు మార్చడానికి, math.degrees()ని ఉపయోగించండి.

print(math.degrees(cmath.phase(c)))
# 45.0

సంక్లిష్ట సంఖ్యల ధ్రువ సమన్వయ పరివర్తన (ధ్రువ అధికారిక ప్రాతినిధ్యం):math,cmathమాడ్యూల్

పైన పేర్కొన్న విధంగా, సంక్లిష్ట సంఖ్య యొక్క సంపూర్ణ విలువ (పరిమాణం) మరియు క్షీణత (దశ) పొందవచ్చు, కానీ cmath.polar() ఉపయోగించి, వాటిని (సంపూర్ణ విలువ, క్షీణత) టుపుల్‌గా పొందవచ్చు.

c = 1 + 1j

print(cmath.polar(c))
print(type(cmath.polar(c)))
# (1.4142135623730951, 0.7853981633974483)
# <class 'tuple'>

print(cmath.polar(c)[0] == abs(c))
# True

print(cmath.polar(c)[1] == cmath.phase(c))
# True

ధ్రువ కోఆర్డినేట్‌ల నుండి కార్టీసియన్ కోఆర్డినేట్‌లుగా మార్చడం cmath.rect()ని ఉపయోగించి చేయబడుతుంది. cmath.rect(సంపూర్ణ విలువ, విచలనం) మరియు సమానమైన కాంప్లెక్స్ కాంప్లెక్స్ కాంప్లెక్స్ రకం విలువలను పొందేందుకు ఇలాంటి ఆర్గ్యుమెంట్‌లను ఉపయోగించవచ్చు.

print(cmath.rect(1, 1))
# (0.5403023058681398+0.8414709848078965j)

print(cmath.rect(1, 0))
# (1+0j)

print(cmath.rect(cmath.polar(c)[0], cmath.polar(c)[1]))
# (1.0000000000000002+1j)

నిజమైన మరియు ఊహాత్మక భాగాలు సంపూర్ణ విలువలు మరియు క్షీణత కోణాల నుండి cosine math.cos() మరియు sine math.sin() ద్వారా లెక్కించబడిన ఫలితాలకు సమానం.

r = 2
ph = math.pi

print(cmath.rect(r, ph).real == r * math.cos(ph))
# True

print(cmath.rect(r, ph).imag == r * math.sin(ph))
# True

సంక్లిష్ట సంఖ్యల గణన (చతుర్భుజం, శక్తులు, వర్గమూలాలు)

సాధారణ అంకగణిత ఆపరేటర్లను ఉపయోగించి నాలుగు అంకగణిత కార్యకలాపాలు మరియు శక్తి గణనలను నిర్వహించవచ్చు.

c1 = 3 + 4j
c2 = 2 - 1j

print(c1 + c2)
# (5+3j)

print(c1 - c2)
# (1+5j)

print(c1 * c2)
# (10+5j)

print(c1 / c2)
# (0.4+2.2j)

print(c1 ** 3)
# (-117+44j)

స్క్వేర్ రూట్‌ను **0.5తో గణించవచ్చు, కానీ అది లోపాన్ని పరిచయం చేస్తుంది. cmath.sqrt() ఖచ్చితమైన విలువను లెక్కించడానికి ఉపయోగించవచ్చు.

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

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

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

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

ఇది సంక్లిష్ట రకాలు, పూర్ణాంక రకాలు మరియు ఫ్లోట్ రకాలతో అంకగణిత కార్యకలాపాలను కూడా చేయగలదు.

print(c1 + 3)
# (6+4j)

print(c1 * 0.5)
# (1.5+2j)