Python’da Değişken Tanımlama ve Değer Atama

Python’da değişken tanımlamak için yapmamız gereken tek şey değişken adını belirtmek ve ardından değişkene değer atamak;

<değişken adı> = <değer>

Python, değişkenlere değer atamak için eşittir işaretini (=) kullanır. Değişkeni öncesinde tanımlamaya (veya bir değişken tipi/türü belirtmeye) gerek yoktur. Python değişkenleri oluşturulurken değişkene değer atamak değişkeni tanımlamak için yeterlidir. Bu şekilde değişken tanımlama gerçekleştirilir. Bir değişkeni başlangıç değeri atamadan tanımlamak mümkün değildir – global değişken tanımlamıyorsak.

Örneklerle Python’da değişken tanımlama ve değer atama

# Integer
a = 2
print(a)
# Çıktı: 2

# Integer    
b = 9223372036854775807
print(b)
# Çıktı: 9223372036854775807

# Floating point
pi = 3.14
print(pi)
# Çıktı: 3.14

# String
c = 'A'
print(c)
# Çıktı: A

# String    
isim = 'Ali Veli'
print(isim)
# Çıktı: Ali Veli

# Boolean    
q = True
print(q)
# Çıktı: True

# Boş değer veya null data tipi
x = None
print(x)
# Çıktı: None

Python’da değişkene değer atama soldan sağa doğru işler. Bu nedenle aşağıdaki komutlar bir sözdizimi hatası (SyntaxError) verecektir.

0 = x
=> Çıktı: SyntaxError: can't assign to literal

Python’un kendi anahtar kelimelerini değişken adı olarak kullanamayız.

Python anahtar kelime listesini şu şekilde görebilirsiniz:

import keyword
print(keyword.kwlist)

Python’da değişken adlandırma kuralları nelerdir?

1. Değişken adları bir harf veya alt çizgiyle başlamalıdır.

x = True # geçerli
_y = True # geçerli

9x = False # sayı ile başlıyor
=> SyntaxError: invalid syntax  (Sözdizimi Hatası: geçersiz sözdizimi)

$ y = False # sembol ile başlıyor
=> SyntaxError: invalid syntax  (Sözdizimi Hatası: geçersiz sözdizimi)

2. Adlandırmanın geri kalanı harflerden, sayılardan ve alt çizgilerden oluşabilir.

has_0_in_it = "Hala doğru"

3. büyük/küçük harf duyarlıdır.

x = 9  
y = X*5  
=>NameError: name 'X' is not defined (İsim Hatası: 'X' adı tanımlanmadı)

Python’da değişken tanımlarken veri türü belirtmeye gerek yoktur. Değişken için bellekte gerekli alanı belirlemek için Python yorumlayıcısı tarafından otomatik olarak en uygun veri türü belirlenir.

Python’da integer tanımlama:

a = 2
print(type(a))
# Çıktı: <type 'int'>

b = 9223372036854775807
print(type(b))
# Çıktı: <type 'int'>

Gördüğünüz gibi Python’da int tanımlaması yaparken veri tipini belirtmedik. Peki bir string, float veya başka bir türde değişkeni tanımlasaydık?

Veri türüne type() komutu ile baktığımızı farkettiniz mi? Veri türü öğrenmek için isinstance() metodunu da kullanabilir miydik?

pi = 3.14
print(type(pi))
# Çıktı: <type 'float'>

c = 'A'
print(type(c))
# Çıktı: <type 'str'>

name = 'Ali Veli'
print(type(name))
# Çıktı: <type 'str'>

q = True
print(type(q))
# Çıktı: <type 'bool'>

x = None
print(type(x))
# Çıktı: <type 'NoneType'>

Yine aynı şekilde tür belirtmemize gerek olmayacaktı.

Artık değişken oluşturmanın temellerini biliyoruz. Şimdi Python’da değer atama hakkındaki bir inceliği öğrenebiliriz.

Değer atama işlemi yapmak için eşittir işaretini kullandığımızda, = ‘in solundaki isim sağdaki nesnenin adıdır. Yani, = işareti sağdaki nesnenin referansını soldaki isme atar:

bir_isim = bir_nesne # "bir_isim" artık "bir_nesne" nesnesini refere eden bir isimdir.

Dolayısıyla, yukarıdaki değişken atama örneklerinden, pi = 3.14 örneğine bakarsak, pi, 3.14 nesnesi için bir isimdir – ancak bir nesnenin birden fazla adı olabileceğinden 3.14 nesnesinin tek adı değildir.

Tek satırda değişken atama

Tek bir satırda birden çok değişkene değer atayabiliriz. = operatörünün sağ ve sol taraflarında aynı sayıda bağımsız değişken olması gerektiğine dikkat etmeliyiz:

a, b, c = 1, 2, 3
print(a, b, c)
# Çıktı: 1 2 3

a, b, c = 1, 2
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b, c = 1, 2
=> ValueError: need more than 2 values to unpack (Değer Hatası: 2'den fazla değere ihtiyaç var)

a, b = 1, 2, 3
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b = 1, 2, 3
=> ValueError: too many values to unpack (Değer Hatası: çok fazla değer)

Son örnekteki hatayı boşta kalan değerleri eşit sayıda rastgele değişkene atayarak yok edebiliriz. Bu sahte değişken herhangi bir ada sahip olabilir, ancak istenmeyen değerleri atamak için alt çizgi (_) kullanmak gelenekseldir:

a, b, _ = 1, 2, 3
print(a, b)
# Çıktı: 1, 2

Değişken sayısı ile atanan değerlerin sayısının eşit olması gerektiğini unutmayın. Aksi takdirde, yukarıdaki gibi “ValueError: too many values to unpack” hatasını alırız:

a, b, _ = 1,2,3,4
=>Traceback (most recent call last):
=>File "name.py", line N, in <module>
=>a, b, _ = 1,2,3,4
=>ValueError: too many values to unpack (Beklenen değer sayısı 3)

Aynı anda birkaç değişkene tek bir değer de atayabilirsiniz.

a = b = c = 1
print(a, b, c)
# Çıktı: 1 1 1

Bu tür değişken atamaları yaparken a, b ve c değişkenlerinin üçünün de bellekte aynı nesneye, 1 değerine sahip bir int nesnesine, işaret ettiğini unutmayın. Diğer bir deyişle, a, b ve c üç farklı addır ve aynı int nesnesine verilir. Daha sonra bunlardan birine farklı bir nesne atamak diğerlerini değiştirmez:

a = b = c = 1    # a, b ve c, değeri 1 olan aynı int nesnesine işaret eder
print(a, b, c)
# Çıktı: 1 1 1

b = 2            # b şimdi değeri 2 olan başka bir int nesnesine işaret ediyor
print(a, b, c)
# Çıktı: 1 2 1  # çıktı beklediğimiz gibi

Yukarıdakiler, değişebilen türler (list, dict vb.) için geçerli olduğu gibi değişmez türler (int, string, tuple) için de geçerlidir:

x = y = [7, 8, 9] # x ve y aynı liste nesnesine işaret ediyor, [7, 8, 9]
x = [13, 8, 9] # x şimdi yeni oluşturulmuş farklı bir list nesnesine işaret ediyor, [13, 8, 9]
print (y) # y hala ilk atandığı listeye işaret ediyor
# Çıktı: [7, 8, 9]

Buraya kadar sorun yok. Değişebilen türler için bu şekilde basamaklı değişken atama yöntemini kullanıldığımızda ve nesnenin değiştirilmesi söz konusu ise (yukarıda yaptığımız gibi, adı farklı bir nesneye atamanın aksine) işler biraz farklılaşır. Şimdi aşağıdaki örneğe bakalım:

x = y = [7, 8, 9] # x ve y aynı liste nesnesi için iki farklı addır, [7, 8, 9]
x [0] = 13 # [7, 8, 9] liste nesnesinin değerini isimlerinden biri aracılığıyla güncelliyoruz, bu durumda
print (y) # liste nesnesinin değerini diğer adını kullanarak yazdıralım
# Çıktı: [13, 8, 9] # doğal olarak değişim y'ye de yansıtılır

İç içe geçmiş liste objeleri de Python’da geçerlidir. Bu, bir listenin öğe olarak başka bir listeyi içerebileceği anlamına gelir.

x = [1, 2, [3, 4, 5], 6, 7] # iç içe geçmiş liste
print x[2]
# Çıktı: [3, 4, 5]

print x[2][1] 
# Çıkış: 4

Python’da liste oluşturma/tanımlama ile daha fazla bilgi için Python’da Liste makalemize bakabilirsiniz.

Son olarak, Python değişkenlerinin ilk tanımlandıkları türde kalmaları gerekmez – bir değişkene yeni bir değer atamak için, yani değişken değerini değiştirmek için (bu değer farklı bir türde olsa bile), basitçe = kullanabiliriz.

a = 2
print(a)
# Çıktı: 2

a = "Yeni değer"
print(a)
# Çıktı: Yeni değer

Bu sizin için karışıklığa sebep olacaksa, = ‘in solundaki şeyin yalnızca bir nesne isimi olduğu gerçeğini düşünün. a için önce 2 değerine sahip bir int nesnesini çağırıyoruz. Ardından fikrimizi değiştirip ‘Yeni değer’ değerine sahip bir string (karakter dizisi) nesnesine a adını vermek istiyoruz. Aslında oldukça basit, değil mi?