Python Operatörleri
Python, sahip olduğu operatörleri ile geliştiricilere matematiksel hesaplamalardan mantıksal karşılaştırmalara, bit düzeyi işlemlerden atama işlemlerine kadar geniş bir yelpazede işlevsellik sunar. Bu yazımızda, Python’daki operatörleri listeler halinde sunup her birinin ne işe yaradığına dair açıklamalarda bulunacağız. Hem yeni başlayanlar için temel bir rehber oluşturacak hem de daha deneyimli geliştiricilere hatırlatıcı nitelikte bilgiler sunacağız.
Aritmetik Operatörler
Aritmetik operatörler, matematiksel işlemleri gerçekleştirmek için sayısal değerlerle birlikte kullanılır. Bu operatörler; toplama, çıkarma, çarpma, bölme gibi temel aritmetik işlemler için kullanılır. Haliyle sayısal değerler üzerinde işlem yapmamıza olanak sağlar.
| Operatör | Kullanımı |
|---|---|
+ | Toplama (Addition) |
- | Çıkarma (Subtraction) |
* | Çarpma (Multiplication) |
/ | Bölme (Division) |
% | Mod alma (Modulus) |
** | Üs alma (Exponentiation) |
// | Tam bölme (Floor division) |
x = 20
y = 2
# Toplama (Addition)
print(x + y) # Çıktı: 22
# Çıkarma (Subtraction)
print(x - y) # Çıktı: 18
# Çarpma (Multiplication)
print(x * y) # Çıktı: 40
# Bölme (Division)
print(x / y) # Çıktı: 10.0
# Mod alma (Modulus)
print(x % y) # Çıktı: 0
# Üs alma (Exponentiation)
print(x ** y) # Çıktı: 400
# Tam bölme (Floor division)
print(x // y) # Çıktı: 10Atama Operatörleri
Atama operatörleri, değişkenlere değer atamak için kullanılır. Aşağıdaki tabloda, Python’da atama operatörlerinin nasıl kullanıldığı x değişkeni ve 6 değeri üzerinden gösterilmiştir:
| Operatör | Kısa Kullanım | Uzun Kullanım |
|---|---|---|
= | x = 6 | x = 6 |
+= | x += 6 | x = x + 6 |
-= | x -= 6 | x = x – 6 |
*= | x *= 6 | x = x * 6 |
/= | x /= 6 | x = x / 6 |
%= | x %= 6 | x = x % 6 |
//= | x //= 6 | x = x // 6 |
**= | x **= 6 | x = x ** 6 |
x = 6
# += operatörü
x += 6 # Kısa kullanım: x = x + 6
print(x) # Çıktı: 12
x = 6
x = x + 6 # Uzun kullanım
print(x) # Çıktı: 12
# -= operatörü
x = 6
x -= 6 # Kısa kullanım: x = x - 6
print(x) # Çıktı: 0
x = 6
x = x - 6 # Uzun kullanım
print(x) # Çıktı: 0
# *= operatörü
x = 6
x *= 6 # Kısa kullanım: x = x * 6
print(x) # Çıktı: 36
x = 6
x = x * 6 # Uzun kullanım
print(x) # Çıktı: 36
# /= operatörü
x = 6
x /= 6 # Kısa kullanım: x = x / 6
print(x) # Çıktı: 1.0
x = 6
x = x / 6 # Uzun kullanım
print(x) # Çıktı: 1.0
# %= operatörü
x = 6
x %= 6 # Kısa kullanım: x = x % 6
print(x) # Çıktı: 0
x = 6
x = x % 6 # Uzun kullanım
print(x) # Çıktı: 0
# //= operatörü
x = 6
x //= 6 # Kısa kullanım: x = x // 6
print(x) # Çıktı: 1
x = 6
x = x // 6 # Uzun kullanım
print(x) # Çıktı: 1
# **= operatörü
x = 6
x **= 6 # Kısa kullanım: x = x ** 6
print(x) # Çıktı: 46656
x = 6
x = x ** 6 # Uzun kullanım
print(x) # Çıktı: 46656
❗ Her ne kadar x += 6 ve x = x + 6 (kısa kullanım ile uzun kullanım) ifadeleri işlevsel olarak aynı sonucu üretse de, bu iki ifade arasında özellikle de performansla ilgili bazı farklar vardır. Zira x += 6 ifadesi, x değişkeninin mevcut hafıza adresinde güncelleme yapar. Bu da haliyle hafıza yönetimi açısından daha verimli olmaktadır. Diğer yandan, x = x + 6 ifadesi, x + 6 sonucu için yeni bir hafıza alanı tahsis eder ve bu da ilgili işlemi yavaşlatır. Bu nedenle büyük veri setleriyle çalışırken, x += 6 ifadesini kullanmak hafıza ve hız açısından avantajlı olduğu için tavsiye edilir.
Karşılaştırma Operatörleri
Karşılaştırma operatörleri iki değeri karşılaştırmak için kullanılır. Eğer karşılaştırılan şeyler doğruysa “True” (doğru), yanlışsa “False” döndürür.
| Operatör | Açıklama |
|---|---|
== | eşittir |
!= | eşit değildir |
> | büyüktür |
< | küçüktür |
>= | büyük eşittir |
<= | küçük eşittir |
x = 10
y = 5
# == Eşittir
print(x == y) # Çıktı: False (x ve y eşit değil)
# != Eşit değildir
print(x != y) # Çıktı: True (x ve y eşit değil)
# > Büyüktür
print(x > y) # Çıktı: True (x, y'den büyük)
# < Küçüktür
print(x < y) # Çıktı: False (x, y'den küçük değil)
# >= Büyük eşittir
print(x >= y) # Çıktı: True (x, y'den büyük veya eşit)
# <= Küçük eşittir
print(x <= y) # Çıktı: False (x, y'den küçük veya eşit değil)Mantıksal Operatörler
Mantıksal operatörler, programlamada koşullu ifadeleri birleştirmek ve karşılaştırmalar yapmak için kullanılır. Bu operatörler sayesinde, birden fazla koşulu aynı anda değerlendirebilir ve sonucunda True (doğru) veya False (yanlış) mantıksal değerleri elde ederiz.
| Operatör | Açıklama |
|---|---|
and (ve) | Her iki ifade de doğruysa True döndürür |
or (veya) | İfadelerden biri doğruysa True döndürür |
not (değil) | Tersten değerlendirir; doğruysa False döndürür |
x = 10
y = 5
z = 20
# and operatörü: Her iki koşulun da True olması gerekiyor
print(x > y and z > x) # Çıktı: True (Her iki koşul da doğru)
# or operatörü: En az bir koşulun True olması yeterli
print(x > y or z < y) # Çıktı: True (İlk koşul doğru olduğu için True)
# not operatörü: Koşulun tersini döner
print(not x > y) # Çıktı: False (x > y True olduğu için, not bunu False yapar)Benzerlik Operatörleri
Benzerlik operatörleri, nesnelerin eşit olup olmadıklarını değil de aynı nesne ve aynı bellek konumuna sahip olup olmadıklarını karşılaştırmak için kullanılır.
| Operatör | Açıklama |
|---|---|
is | Her iki değişken de aynı nesneyse True döndürür |
is not | Her iki değişken de aynı nesne değilse True döndürür |
# Aynı nesneye işaret eden iki değişken
a = [1, 2, 3]
b = a # b, a'nın işaret ettiği nesneyi işaret ediyor
# is operatörü: Aynı nesne ve bellek konumuna sahip mi?
print(a is b) # Çıktı: True (a ve b aynı nesneyi gösteriyor)
# Yeni bir liste oluşturan aynı değerlere sahip başka bir değişken
c = [1, 2, 3]
# is operatörü: a ve c aynı nesne mi?
print(a is c) # Çıktı: False (a ve c'nin değeri aynı olsa da farklı nesneler)
# is not operatörü: a ve c farklı nesneler mi?
print(a is not c) # Çıktı: True (a ve c aynı bellek adresine sahip değil)
# a ve b aynı bellek konumuna sahip, bu yüzden is not False döner
print(a is not b) # Çıktı: False (a ve b aynı nesneye işaret ediyor)Bu operatörler, nesnelerin kimliklerini karşılaştırır, dolayısıyla iki değişken aynı değere sahip olsalar bile, eğer farklı bellek adreslerinde depolanıyorsa is operatörü False döner.
Üyelik Operatörleri
Üyelik operatörleri, nesnede bir dizinin sunulup sunulmadığını test etmek için kullanılır.
| Operatör | Açıklama | Örnek | Sonuç |
|---|---|---|---|
in | Nesnede belirtilen değere sahip bir dizi varsa True döndürür | x in y | True |
not in | Nesnede belirtilen değere sahip bir dizi yoksa True döndürür | x not in y | False |
# Bir listede öğe kontrolü
my_list = [1, 2, 3, 4, 5]
# in operatörü: 3 sayısı my_list içinde mi?
print(3 in my_list) # Çıktı: True (3 listede bulunuyor)
# not in operatörü: 6 sayısı my_list içinde mi?
print(6 not in my_list) # Çıktı: True (6 listede bulunmuyor)
# Bir stringde karakter kontrolü
my_string = "Python programlama"
# in operatörü: 'P' harfi string içinde mi?
print('P' in my_string) # Çıktı: True ('P' string içinde bulunuyor)
# not in operatörü: 'z' harfi string içinde mi?
print('z' not in my_string) # Çıktı: True ('z' string içinde bulunmuyor)
# Bir sözlükte anahtar kontrolü
my_dict = {"ad": "Ali", "yaş": 25}
# in operatörü: "ad" anahtarı sözlükte mi?
print("ad" in my_dict) # Çıktı: True ("ad" anahtarı sözlükte mevcut)
# not in operatörü: "soyad" anahtarı sözlükte mi?
print("soyad" not in my_dict) # Çıktı: True ("soyad" anahtarı sözlükte bulunmuyor)Bitsel Operatörler
Python’da bitsel operatörler (bitwise operators), sayıları bit seviyesinde işlemek için kullanılır. Sayılar, ikilik (binary) tabanda işlem görür, yani 0’lar ve 1’ler üzerinden çalışır. Bu operatörler, bit düzeyinde mantıksal işlemler yaparak sonuç döner. Özellikle performansın önemli olduğu veya düşük seviyeli işlemlerin gerektiği durumlarda kullanılır.
| Operatör | Açıklama |
|---|---|
& (AND) | İki sayının ikilik karşılıkları bit bazında karşılaştırılır ve her iki bit de 1 ise sonuç 1 olur. |
| (OR) | Bitlerden biri veya her ikisi 1 ise sonuç 1 olur. |
^ (XOR) | Bitlerden sadece biri 1 ise sonuç 1 olur. İki bit de aynıysa (her ikisi de 0 veya her ikisi de 1 ise), sonuç 0 olur. |
~ (NOT) | Tüm bitleri ters çevirir |
<< (sola 0 kaydırma) | Bitler belirtilen sayıda sola kaydırılır ve boş kalan yerlere sıfır eklenir. |
>> (sağa 0 kaydırma) | Bitler belirtilen sayıda sağa kaydırılır ve boş kalan yerlere sıfır eklenir. |
a = 10 # 10'un ikilik karşılığı: 1010
b = 4 # 4'ün ikilik karşılığı: 0100
# &
print(a & b) # Çıktı: 0 (1010 & 0100 = 0000)
# |
print(a | b) # Çıktı: 14 (1010 | 0100 = 1110)
# ^
print(a ^ b) # Çıktı: 14 (1010 ^ 0100 = 1110)
# ~
print(~a) # Çıktı: -11 (a'nın tersinin alınmış hali)
# <<
print(a << 2) # Çıktı: 40 (1010 iki basamak sola kayar = 101000)
# >> Bitsel sağa kaydırma (Right Shift)
print(a >> 2) # Çıktı: 2 (1010 iki basamak sağa kayar = 10)