Python’da Değişken Oluşturma ve Değer Atama

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

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

Python, değişkenlere değer atamak için = işaretini kullanır. Önceden değişkeni tanımlamaya (veya bir veri türü belirtmeye) gerek yoktur. Bir değişkene değer atamak değişkeni tanımlamak için yeterlidir ve değişkeni oluşturur. 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 oluşturma

# 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

Değişken 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)
  1. Adlandırmanın geri kalanı harflerden, sayılardan ve alt çizgilerden oluşabilir.
has_0_in_it = "Hala doğru"
  1. 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 data 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 data türü belirlenir.

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

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

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'>

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

Bir atama işlemi yapmak için = 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 birçok 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

_ sayısı ile kalan 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 basamaklı 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

Son olarak, Python’daki değişkenlerin ilk tanımlandıkları türde kalmaları gerekmez – bir değişkene yeni bir değer atamak 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 basit, değil mi?



Bir yorum yapın

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

To top