Folosind math, modulul standard Python pentru funcții matematice, puteți calcula funcții exponențiale și logaritmice (logaritm natural, logaritm obișnuit și logaritm binar).
Următoarele aspecte sunt explicate aici, împreună cu un exemplu de cod.
- Baza logaritmului natural (număr Napier):
math.e - Putere::
**operator,pow(),math.pow() - Rădăcină pătrată (rădăcină):
math.sqrt() - Funcția exponențială (funcție exponențială naturală):
math.exp() - o funcție logaritmică:
math.log(),math.log10(),math.log2()
Baza logaritmului natural (număr Napier): math.e
Baza logaritmului natural (numărul Napier) este furnizată ca o constantă în modulul matematic, notată cu math.e.
import math
print(math.e)
# 2.718281828459045
Putere: ** operator, pow(), math.pow(): **operator, pow(), math.pow()
Pentru a calcula puteri, utilizați fie operatorul **, fie funcția încorporată pow(), fie math.pow().
Pătratul y al lui x se obține după cum urmează
x**ypow(x, y)math.pow(x, y)
print(2**4)
# 16
print(pow(2, 4))
# 16
print(math.pow(2, 4))
# 16.0
math.pow() convertește argumentul într-un tip de virgulă mobilă. Pe de altă parte, funcția încorporată pow() din Python utilizează __pow()__ definită pentru fiecare tip.
De exemplu, pow() permite ca tipurile complexe să fie specificate ca argumente, dar math.pow() nu poate converti tipurile complexe în tipuri float, ceea ce duce la o eroare.
print(pow(1 + 1j, 2))
# 2j
# print(math.pow(1 + 1j, 2))
# TypeError: can't convert complex to float
Funcția încorporată Python pow() permite, de asemenea, un al treilea argument, pow(x, y, z), care returnează restul (rămășița) lui z la puterea y a lui x. Este același calcul ca pow(x, y) % z, dar pow(x, y, z) este mai eficient.
print(pow(2, 4, 5))
# 1
Rădăcină pătrată (rădăcină): math.sqrt()
Rădăcina pătrată (root) poate fi setată la **0,5 folosind ** sau math.sqrt().
print(2**0.5)
# 1.4142135623730951
print(math.sqrt(2))
# 1.4142135623730951
print(2**0.5 == math.sqrt(2))
# True
La fel ca math.pow(), math.sqrt() convertește argumentele în tipuri de virgulă mobilă pentru procesare, astfel încât specificarea unui tip care nu poate fi convertit într-un tip float va avea ca rezultat o eroare de tip TypeError.
print((-3 + 4j)**0.5)
# (1.0000000000000002+2j)
# print(math.sqrt(-3 + 4j))
# TypeError: can't convert complex to float
De asemenea, math.sqrt() nu poate procesa valori negative, rezultând o eroare ValueError.
print((-1)**0.5)
# (6.123233995736766e-17+1j)
# print(math.sqrt(-1))
# ValueError: math domain error
Rețineți că, atunci când este vorba de numere complexe, exemplul care utilizează operatorul ** prezintă o eroare, dar modulul cmath oferă o valoare mai precisă. Valorile negative pot fi, de asemenea, tratate.
import cmath
print(cmath.sqrt(-3 + 4j))
# (1+2j)
print(cmath.sqrt(-1))
# 1j
Funcția exponențială (funcție exponențială naturală): math.exp()
Pentru a calcula puterea bazei logaritmului natural (număr Napier) e, utilizați math.exp().
math.exp(x) returnează x la pătrat de e.
math.exp(x) nu este echivalent cu „math.e ** x”, iar math.exp(x) este mai precis.
print(math.exp(2))
# 7.38905609893065
print(math.exp(2) == math.e**2)
# False
o funcție logaritmică: math.log(), math.log10(), math.log2()
Pentru a calcula funcția logaritmică, utilizați math.log(),math.log10(),math.log2().
math.log(x, y) returnează logaritmul lui x cu y ca bază.
print(math.log(25, 5))
# 2.0
În cazul în care al doilea argument este omis, logaritmul natural este prezentat mai jos.
logaritm
În matematică, logaritmul natural (logaritm cu numărul Napier e ca bază), reprezentat prin log sau ln, poate fi calculat prin math.log(x).
print(math.log(math.e))
# 1.0
logaritm (baza 10)
Logaritmul obișnuit (logaritm cu baza 10) poate fi calculat cu math.log10(x), care este mai precis decât math.log(x, 10).
print(math.log10(100000))
# 5.0
logaritm binar
Logaritmul binar (logaritm cu baza 2) poate fi calculat cu math.log2(x), care este mai precis decât math.log(x, 2).
print(math.log2(1024))
# 10.0
