Temel Matematik Operatörleri

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.

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                  # = -1

Hem 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) # = 1

float 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                 # = 1

tü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.5

Tavsiye 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.0

Olası 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)     # = 8

Yerleş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.0

math.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.23606797749979

math.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.0

Yerinde İş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)     # = 6

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: * 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)     # = 1

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)

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     # 2

Veya operator modülünü kullanarak:

import operator

operator.mod(3 , 4)     # 3
operator.mod(10 , 2)    # 0
operator.mod(6 , 4)     # 2

Negatif sayılar da kullanabilirsiniz.

-9 % 7     # 5
9 % -7     # -5
-9 % -7    # -2

Tamsayı 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
Bu yazı topluluk tarafından oluşturuldu. Lisans bilgisine bakabilirsiniz. Yanlış veya eksik bilgileri düzenlemek için github üzerinden katkıda bulunabilirsiniz.

Kategoriler: Ders, Python

konular

Okumaya devam et!
Sonraki Yazı: Döngüler

Programlamada en temel fonksiyonlardan biri döngülerdir.

Python’da birden fazla satırda kod nasıl yazılılr?

Birden çok satıra bölmek istediğimiz uzun bir kod satırımız olsun.

Python101 – Kararlar

If deyimi Her zaman olduğu gibi, yeni bir bölüme başlarken bir ısınma alıştırmasının iyi olduğunu düşünüyoruz.

Python101 – Nesne Yönelimli Programlama

Nesne Yönelimli Programlama Şimdiye kadar yaptığınız programlama prosedüreldi.

Python’da dosya okuma ve yeni satırları kırpma

Python’daki bir dosyayı okumak ve yeni satırları kırpmak istiyoruz.

Yorum Gönderin

E-posta hesabınız yayımlanmayacak.

koddla
Tema Mundana by WowThemes.net.