Python, tamsayı ve float bölme, çarpma, üs alma, toplama ve çıkarma dahil olmak üzere yaygın matematiksel işlemlerini başka bir modüle ihtiyaç duymadan yapabilir. Matematik modülü (tüm standart Python sürümlerinde bulunur) trigonometrik fonksiyonlar, kök işlemleri, logaritma ve daha fazlası gibi genişletilmiş işlevler sunar.
Bölme işlemi
Python, her iki işlenen de tamsayı olduğunda tamsayı bölme işlemi yapar. Python’un bölme operatörlerinin davranışı Python 2.x ve 3.x’ten itibaren değişmiştir.
a, b, c, d, e = 3, 2, 2.0, -3, 10
Python 2’de ‘ / ‘ operatörünün sonucu pay ve paydanın türüne bağlıdır.
a / b # = 1
a / c # = 1.5
d / b # = -2
b / a # = 0
d / e # = -1Hem a hem de b int olduğu için sonucun bir int olduğuna dikkat edin.
Sonuç her zaman aşağı yuvarlanır (floor).
c bir float olduğundan, a / c işleminin sonucu bir floattır.
Buna ilaveten operator modülü de kullanılabilir:
import operator # operatör modülü 2 argümanlı aritmetik fonksiyonlar sağlar
operator.div(a, b) # = 1
operator.__div__(a, b) # = 1float bölme istiyorsanız aşağıdaki yöntem tavsiye edilen kullanımdır:
from __future__ import division # Python 3 tarzı bölmeyi tüm modüle uygular
a / b # = 1.5
a // b # = 1tüm modüle uygulamak istemiyorsanız:
a / (b * 1.0) # = 1.5
1.0 * a / b # = 1.5
a / b * 1.0 # = 1.0 (işlem sırasına dikkat edin)
from operator import truediv
truediv(a, b) # = 1.5Tavsiye edilmez (örneğin argüman karmaşıksa TypeError yükseltebilir):
float(a) / b # = 1.5 a / float(b) # = 1.5
Python 2’deki ‘ // ‘ operatörü, türden bağımsız olarak yuvarlanmış bölmeyi zorlar.
a // b # = 1 a // c # = 1.0
Python 3’te / operatörü türlerden bağımsız olarak ‘doğru’ bölme işlemini gerçekleştirir. // operatörü yuvarlanmış bölme işlemini gerçekleştirir ve türü korur.
a / b # = 1.5
e / b # = 5.0
a // b # = 1
a // c # = 1.0
import operator # operatör modülü 2 argümanlı aritmetik fonksiyonlar sağlar
operator.truediv(a, b) # = 1.5
operator.floordiv(a, b) # = 1
operator.floordiv(a, c) # = 1.0Olası kombinasyonlar (yerleşik türler için):
- int ve int (Python 2’de int ve Python 3’te float verir)
- int ve float (bir float verir)
- int ve kompleks (bir kompleks verir)
- float ve float (bir float verir)
- float ve kompleks (bir kompleks verir)
- karmaşık ve kompleks (bir kompleks verir)
Daha detaylı bilgi için PEP 238‘e bakabilirsiniz.
Toplama işlemi
a, b = 1, 2
# "+" operatörünü kullanarak:
a + b # = 3
# Eklemek ve atamak için "yerinde" "+=" operatörünü kullanma:
a += b # a = 3 (a = a + b'ye eşdeğerdir)import operator # örnekler için 2 argümanlı aritmetik fonksiyonlar içerir
operator.add(a, b) # = 5 a bu satırdan hemen önce 3 olarak ayarlandığından
# "+=" operatörü şu anlama gelir:
a = operator.iadd(a, b) # a = 5 çünkü a bu satırdan hemen önce 3 olarak ayarlanmıştıOlası kombinasyonlar (yerleşik türler):
- int ve int (int verir)
- int ve float (float verir)
- int ve kompleks (kompleks verir)
- float ve float (float verir)
- float ve kompleks (kompleks verir)
- karmaşık ve kompleks (kompleks verir)
Not: + operatörü ayrıca dizeleri, listeleri ve tuple’ları birleştirmek için de kullanılır:
"first string " + "second string" # = 'first string second string' [1, 2, 3] + [4, 5, 6] # = [1, 2, 3, 4, 5, 6]
Üs alma işlemi
a, b = 2, 3
(a ** b) # = 8
pow(a, b) # = 8
import math
math.pow(a, b) # = 8.0 (her zaman float; karmaşık sonuçlara izin vermez)
import operator
operator.pow(a, b) # = 8Yerleşik pow ile math.pow arasındaki bir diğer fark, yerleşik pow’un üç argüman kabul edebilmesidir:
a, b, c = 2, 3, 2
pow(2, 3, 2) # 0 sonucunu verir, (2 ** 3) % 2 olarak hesaplar, ancak Python dokümanlarına göre bunu daha verimli bir şekilde yaparÖzel fonksiyonlar
math.sqrt(x) işlevi x’in karekökünü hesaplar.
import math
import cmath
c = 4
math.sqrt(c) # = 2.0 (her zaman float; karmaşık sonuçlara izin vermez)
cmath.sqrt(c) # = (2+0j) (her zaman karmaşık)Küp kök gibi diğer kökleri hesaplamak için, sayıyı kökün derecesinin tersine yükseltin. Bu, üstel fonksiyonlardan veya operatörlerden herhangi biriyle yapılabilir.
import math
x = 8
math.pow(x, 1/3) # 2.0
x**(1/3) # 2.0math.exp(x) işlevi e ** x değerini hesaplar.
math.exp(0) # 1.0 math.exp(1) # 2.718281828459045 (e)
math.expm1(x) işlevi e ** x – 1’i hesaplar. x küçük olduğunda, bu math.exp(x) – 1’den önemli ölçüde daha iyi hassasiyet sağlar.
math.expm1(0) # 0.0
math.exp(1e-6) - 1 # 1.0000004999621837e-06
math.expm1(1e-6) # 1.0000005000001665e-06
# tam sonuç # 1.000000500000166666708333341666...Trigonometrik Fonksiyonlarla işlemler
a, b = 1, 2
import math
math.sin(a) # 'a'nın radyan cinsinden sinüsünü döndürür
# Çıktı: 0.8414709848078965
math.cosh(b) # 'b'nin radyan cinsinden ters hiperbolik kosinüsünü döndürür
# Çıktı: 3.7621956910836314
math.atan(math.pi) # 'pi' değerinin radyan cinsinden yay tanjantını döndürür
# Çıktı: 1.2626272556789115
math.hypot(a, b) # math.sqrt(a*a + b*b) ile aynı olan Öklid normunu döndürür
# Çıktı: 2.23606797749979math.hypot(x, y)’nin aynı zamanda orijinden (x, y) noktasına olan vektörün uzunluğu (veya Öklid mesafesi) olduğunu unutmayın.
İki nokta (x1, y1) & (x2, y2) arasındaki Öklid mesafesini hesaplamak için aşağıdaki gibi math.hypot kullanabilirsiniz
math.hypot(x2-x1, y2-y1)
Radyan -> derece ve derece -> radyan arasında dönüşüm yapmak için sırasıyla math.degrees ve math.radians kullanın
math.degrees(a)
# Çıktı: 57.29577951308232
math.radians(57.29577951308232)
# Çıktı: 1.0Yerinde İşlemler
Uygulamalarda bunun gibi kodlara ihtiyaç duyulması yaygındır:
a = a + 1
veya
a = a * 2
Bu yerinde işlemler için etkili bir kısayol bulunur:
a += 1 # ve a *= 2
Yerinde işlem yapmak için ‘=’ karakterinden önce herhangi bir matematiksel operatör kullanılabilir:
- -= değişkeni yerinde azaltır
- += değişkeni yerinde artırır
- *= değişkeni yerinde çarpın
- /= değişkeni yerinde böler
- //= floor değişkeni yerinde böler # Python 3
- %= yerinde değişkenin modülünü döndürür
- **= yerinde üs yükseltme
Bitsel operatörler (^, | vb.) için başka yerinde operatörler de mevcuttur.
Çarpma
a, b = 2, 3
a * b # = 6
import operator
operator.mul(a, b) # = 6Olası kombinasyonlar (yerleşik türler):
- int ve int (int verir)
- int ve float (float verir)
- int ve kompleks (kompleks verir)
- float ve float (float verir)
- float ve kompleks (kompleks verir)
- karmaşık ve kompleks (kompleks verir)
Not: * işleci ayrıca dizelerin, listelerin ve tuple’ların tekrarlanan birleştirilmesi için de kullanılır:
3 * 'ab' # = 'ababab'
3 * ('a', 'b') # = ('a', 'b', 'a', 'b', 'a', 'b')Logaritma ile işlemler
Varsayılan olarak, math.log işlevi bir sayının logaritmasını hesaplar (taban e). İsteğe bağlı olarak ise ikinci bağımsız değişken kullanarak bir taban belirtebilirsiniz.
import math
import cmath
math.log(5) # = 1.6094379124341003
# isteğe bağlı temel bağımsız değişken. Varsayılan math.e
math.log(5, math.e) # = 1.6094379124341003
cmath.log(5) # = (1.6094379124341003+0j)
math.log(1000, 10) # 3.0 (her zaman float)
cmath.log(1000, 10) # (3+0j)math.log fonksiyonunun farklı bazlar için özel varyasyonları mevcuttur.
# Logaritma taban e - 1 (düşük değerler için daha yüksek hassasiyet)
math.log1p(5) # = 1.791759469228055
# Logaritma taban 2
math.log2(8) # = 3.0
# Logaritma taban 10
math.log10(100) # = 2.0
cmath.log10(100) # = (2+0j)Çıkarma işlemi
a, b = 1, 2
# "-" operatörünü kullanarak:
b - a # = 1
import operator # 2 argümanlı aritmetik fonksiyonlar içerir
operator.sub(b, a) # = 1Olası kombinasyonlar (yerleşik türler):
- int ve int (int verir)
- int ve float (float verir)
- int ve kompleks (kompleks verir)
- float ve float (float verir)
- float ve kompleks (kompleks verir)
- karmaşık ve kompleks (kompleks verir)
Modül alma işlemi
Diğer birçok dilde olduğu gibi Python da modül hesaplamak için % operatörünü kullanır.
3 % 4 # 3
10 % 2 # 0
6 % 4 # 2Veya operator modülünü kullanarak:
import operator
operator.mod(3 , 4) # 3
operator.mod(10 , 2) # 0
operator.mod(6 , 4) # 2Negatif sayılar da kullanabilirsiniz.
-9 % 7 # 5
9 % -7 # -5
-9 % -7 # -2Tamsayı bölme işleminin ve modülün sonucunu bulmanız gerekiyorsa, divmod işlevini kısayol olarak kullanabilirsiniz:
quotient, remainder = divmod(9, 4) # quotient = 2, remainder = 1 as 4 * 2 + 1 == 9