Python - Operatörler

Python programlama dili ile notlarımı aktarmaya operatörler ile devam ediyorum. Bu ve sonrasında yayınlayacağım yazılarda yakın zamanda tamamladığım DataCamp eğitimlerinden edindiğim bilgilere ve örneklere yer vermeye çalışacağım.
AA

Python programlama dili pek çok diğer programlama dilinde de olduğu üzere zengin bir operatör (işleç) çeşitliliğine sahip. Ancak, elbette diller arasında bazı kapsam ve işlev farklılıkları da söz konusu olabiliyor1.

Son olarak, bazı işlemleri bir standart Python kütüphanesi olan operator tarafından barındırılan fonksiyonlar aracılığı de gerçekleştirebilmek mümkün. Bu tür işlemler için elbette ilgili kütüphanenin eklenmiş olması gerekmekte2.

import operator

İlgili işlemlere dair kod örnekleri içerisinde operator.fonksiyon_adi() şeklinde görebilirsiniz.

Matematiksel Operatörler (Arithmetic Operators)

Matematiksel operatörler, verilen değerleri kullanarak matematik işlemler gerçekleştirebilmemizi sağlar.

Operatör İşlev Örnek
+ Toplama (addition) x + y
- Çıkarma (subtraction) x - y
* Çarpma (multiplication) x * y
/ Bölme (division) x / y
% Mod alma (modulus) x % y
** Üs (kuvvet) alma (exponentiation) x ** y
// Tam sayı bölme (floor division) x // y 
x, y = 189, 571

print(x + y) # output: 760
print(y - x) # output: -382
print(x * y) # output: 107919
print(y / x) # output: 3.0211640211640214
print(y % x) # output: 4
print(y ** 2) # output: 326041
print(x // 2) # output: 94

operator.add(x, y) # output: 760
operator.sub(x, y) # output: -382
operator.mul(x, y) # output: 107919
operator.truediv(y, x) # output: 3.0211640211640214
operator.mod(y, x) # output: 4
operator.pow(x, 2) # output: 326041
operator.floordiv(x, 2) # output: 94

Bazı matematiksel operatörleri string değerler ile birlikte de kullanabilmekteyiz.

Operatör İşlev Örnek
+ String değerleri birleştirir x + y
* String bir değeri belirtilen sayısal değer kadar tekrarlar x * y 
x, y = 189, 571
print(str(x) + str(y))
print(str(x) * 2)

operator.concat(str(x), str(y))
operator.mul(str(x), 2)

% ise string formatting veya string interpolation olarak ifade edilen, string içi yer tutuculara (place holder) değer atayabilmemizi sağlayan özel bir operatördür. Bu konuyu ayrı bir yazıda detaylıca ele alacağım. Şimdilik basit bir örnek ile ilgili operatörün kullanımını göstereceğim.

print('%s %s' % ('Hello', 'World'))

Mantıksal Operatörler (Logical Operators)

Bir durumun (operand) şartlar bağlamında (ve, veya, değil) Doğru (True) ya da Yanlış (False) olarak tanımlanabilmesini sağlayan operatörlerdir.

Operatör İşlev Örnek
and Her iki durum da True ise True x and y
or Durumlardan herhangi biri True ise True x or y
not Durum(lar) False ise True not x 
nums = [1, 5, 11]

[n < 5 and n < 10 for n in nums] # output: [True, False, False]
[n < 5 or n > 1 for n in nums] # output: [True, True, True]
[not(n < 5 and n < 10) for n in nums] # output: [False, True, True]

Giriş paragrafında da belirttiğim gibi, diller arasında bazı farklılıklar olabilmekte. Örneğin, Python &&, || ve ! operatörleri yerine and, or ve not operatörlerini kullanmakta.

Operatör Diğer dillerdeki karşılığı
and &&
or ||
not ! 
n = 1
print(n < 5 && n < 10) # SyntaxError: invalid syntax

Desteklenmeyen operatörlerin kullanımında SyntaxError dönecektir. Diğer yandan, Python mantıksal operatörler bağlamında ikili (bitwise/binary) operatörlerini kullanmaya izin verir. İlgili operatörlere dair detaylar için İkili Düzeyde Operatörler başlığında bakabilirsiniz.

Mantıksal operatör İkili operatör
and &
or |

Gelelim mantıksal operatörler ile ilgili örneklere.

Elimizde 189 ve 571 sayıları olsun. Aşağıdaki örnekte şartların ikisinin de doğru olması sonucunda belirtilen son ifade print ile döndürülecektir.

x, y = 189, 571

print(x and y) # output: 571
print(x or y) # output: 189

İkili Düzeyde Operatörler (Bitwise Operators)

Python dili mantıksal işlemleri binary (ikili) düzeyde de gerçekleştirebilmemize olanak tanır. Bu amaçla çeşitli operatörlerden faydalanabilmekteyiz3.

Operatör İşlev Örnek
& İkili düzeyde and x & y
| İkili düzeyde or x | y
~ İkili düzeyde not ~x
^ İkili düzeyde xor x ^ y
>> İkili düzeyde sağa kaydırma (right shift) x>>
<< İkili düzeyde sola kaydırma (left shift) x<<

Bir önceki örnekte yer alan sayıları bu defa & ile ikili düzeyde yineleyelim. Örneği tam olarak anlayabilmek için ilgili sayıların binary (ikili) karşılıklarına ihtiyacımız olacak.

0'ın ikili karşılığı '0'
1'in ikili karşılığı '1'
2'nin ikili karşılığı '10'
3'ün ikili karşılığı '11'
4'ün ikili karşılığı '100'
5'in ikili karşılığı '101'
.
.
[bin(n).replace('0b', '') for n in [189, 571]] # ['10111101', '1000111011']

Şimdi örneğimize geçebiliriz.

x = 189 # 10111101
y = 571 # 1000111011
print(x & y) # output: 57 - '111001'

operator.and_(x, y) # output: 57 - '111001'
operator.xor(x, y) # output: 646 - '1010000110'
operator.or_(x, y) # output: 703 - '1010111111'

Peki, 57 sonucuna nasıl ulaştık?

Öncelikle 10111101 ile 0010111101 değerlerinin aynı olduğunu bilmelisiniz. Hatırlarsanız, ikili sayılarda değerleri 1 ile ifade etmekteydik. Dolayısıyla, ilk olarak & ile karşılaştırma yapabilmemiz için hane sayılarını eşitlememiz gerekiyor. Ardından, her haneyi & bağlamında karşılaştırıyoruz.

|0|0|1|0|1|1|1|1|0|1|
|1|0|0|0|1|1|1|0|1|1|
-------- & ----------
|0|0|0|0|1|1|1|0|0|1|
-------- | ----------
|1|0|1|0|1|1|1|1|1|1|
-------- ^ ----------
|1|0|1|0|0|0|0|1|1|0|

Bu karşılaştırma neticesinde elde ettiğimiz karşılık 111001 oluyor. Özetlemek gerekirse, and her iki değerin mantıksal olarak True olup olmadığına bakarken & her iki değerin ikili karşılıkları üzerinden and işlemini gerçekleştirir. Yine açıklama alanında or, not ve xor için dönen değerleri görebilirsiniz. Son olarak, x için diğer operatörlerin döndürdükleri değerlere de bir bakalım.

print(x) # output: 189 - '10111101'

print(~x) # output: -190 - '10111110'
operator.invert(x)

print(x << 2) # output: 756 - '1011110100'
operator.lshift(x)

print(x >> 2) # output: 47 - '101111'
operator.rshift(x)

x değişkeni 189 değerine ve bu değer de 10111101 ikili karşılığınba sahip. ~ operatörü ikili değeri çevirme (flipping) özelliğine sahiptir. Yani, x değerine 1 ekleyip - ile çarpar. Bu durumda da elde edeceğimiz ikili karşılık 10111110 olacaktır.

>> operatörü değeri verilen değer kadar sağa, << ise sola kaydırır. Kaydırma işleminde kaydırılan basamak kadar 0 eklenir.

Karşılaştırma Operatörleri (Comparison Operators)

Operatör İşlev Örnek
== Eşittir; her iki durum da eşitse True x == y
!= Eşit değildir; iki taraf da birbirine eşit değilse True x != y
< Küçükse; sağdaki değer soldaki değerden büyük ise True x < y
<= Küçük ve eşit ise; eşitliğin sağındaki değer soldaki değere eşit veya soldaki değerden büyük ise True x <= y
> Büyükse; soldaki değer sağdaki değerden büyük ise True x > y
>= Büyük ve eşit ise; eşitliğin soldaki değer sağdaki değere eşit ya da sağdaki değerden büyük ise True x >= y 
x, y = 189, 571
print(x < y) # output: True
print(x == y) # output: False

operator.lt(x, y) # output: True
operator.gt(x, y) # output: False
operator.ge(x, y) # output: False
operator.le(x, y) # output: True
operator.ne(x, y) # output: True
operator.eq(x, y) # output: False

Kimlik Operatörleri (Identity Operators)

Operatör İşlev Örnek
is Her iki değişken aynı değere sahipse True x is y
is not Her iki değişken aynı değere sahip değilse True x is not y 
x, y = 189, 571
print(x is y) # output: False
print(x is not y) # output: True

operator.is_(x, y) # output: False
operator.is_not(x, y) # output: True

Aitlik Operatörleri (Membership Operators)

Operatör İşlev Örnek
in Belirtilen değer dizi içerisindeki bir eleman (member) değeri ile eşleşiyor ise True x in y
not in Belirtilen değer dizi içerisindeki herhangi bir eleman (member) değeri ile eşleşmiyor ise True x not in y 
print('a' in 'abcd') # output: True
print('1' not in 'abcd') # output: True

operator.contains('abcd', 'a') # output: True
not operator.contains('abcd', '1') # output: True
not(operator.contains('abcd', '1')) # output: True

Atama Operatörleri (In-place Operators)

Değişkenlere veri atarken atama operatörlerini kullanırız. En yalın kullanımı degisken_adi = degisken_degeri şeklindedir. Kimi durumlarda değerin kendisini matematiksel işleme dahil ederek işlem sonucunun değer olarak atanmasını isteyebiliriz. Bu tür durumlarda değişken adının tekrarı yerine yerinde atama kullanımlarını tercih ederiz4.

Operatör İşlev Örnek Açık Kullanım
= y değerini x değerine atar, en yalın değer atama işlemidir x = y
+= y değeri ile x değişkeninin sahip olduğu değer ile toplar, sonucu x değişkenine atar x += y x = x + y
-= y değerini x değişkeninin sahip olduğu değerden çıkarır, sonucu x değişkenine atar x -= y x = x - y
*= y değerini x değişkeninin sahip olduğu değer ile çarpar, sonucu x değişkenine atar x *= y x = x * y
/= x değişkeninin sahip olduğu değeri y değişkenine böler ve sonucu x değişkenine atar x /= y x = x / y
%= x değişkeninin y değeri kadar modunu alır ve sonucu x değişkenine atar x %= y x = x % y
**= x değişkeninin y değeri kadar üssünü alır ve sonucu x değişkenine atar x **= y x = x ** y
//= x değişkeninin y kökünü alır ve sonucu x değişkenine atar x //= y x = x // y
&= x ve y değerlerine ikili düzeyde and işlemini uygular ve sonucu x değişkenine atar x &= y x = x & y
|= x ve y değerlerine ikili düzeyde or işlemini uygular ve sonucu x değişkenine atar x |= y x = x | y
^= x ve y değerlerine ikili düzeyde xor işlemini uygular ve sonucu x değişkenine atar x ^= y x = x ^ y
>>= x değişkenini ikili düzeyde y kadar sağa kaydırır ve sonucu x değişkenine atar x >>= y x = x >> y
<<= x değişkenini ikili düzeyde y kadar sola kaydırır ve sonucu x değişkenine atar x <<= y x = x << y

Yukarıdaki tabloyu örnekler ve operator paketinin sahip olduğu fonksiyonlarla açıklayalım.

x, y = 10, 2
a, b = 'Hello', 'World'

x = operator.iadd(x, y) # x += y # output: 12
a = operator.iadd(a, b) # x += y # output: HelloWorld
x = operator.iand(x, y) # x &= y # output: 0
x = operator.iconcat(str(x), str(y)) # x += y # output: 02
x = operator.ifloordiv(x, y) # x //= 5
x = operator.ilshift(x, y) # x <<= y # output: 40
x = operator.imul(x, y) # x *= y # output: 20
x = operator.ior(x, y) # x |= y # output: 10
x = operator.ipow(x, y) # x **= y # output: 100
x = operator.irshift(x, y) # x >>= y # output: 2
x = operator.isub(x, y) # x -= y # output: 8
x = operator.itruediv(x, y) # x /= y # output: 5.0
x = operator.ixor(x, y) # x ^= y # output: 8

Bir sonraki yazıda, operatörlerle ilgili ek örnekler de yer alacak şekilde döngülere değinmeye çalışacağım. İlgili yazılar Python kategorisi aracılığı ile takip edilebilir.

  1. Operator precedence. The Python Language Reference ↩
  2. Mapping Operators to Functions. Standard operators as functions. The Python Language Reference ↩
  3. Bitwise operators. Python Wiki ↩
  4. Python Öğren Belgeleri ↩
Yorum alanını göster
Beğendim
Beğenmedim