Python 3’te Değişkenler Nasıl Kullanılır?

Python 3’te Değişkenler Nasıl Kullanılır?

Giriş: Programlamanın Temel Taşı – Değişkenler

Programlama dünyasında, veri işleme ve depolama merkezi bir rol oynar. Bir yazılımın çalışabilmesi için sayıları, metinleri, listeleri veya daha karmaşık yapıları geçici olarak hafızada tutması ve bu verilere erişebilmesi gerekir. İşte tam bu noktada “değişkenler” devreye girer. Değişkenler, bilgisayar belleğinde belirli bir değeri saklamak için kullanılan adlandırılmış depolama alanlarıdır. Bir nevi, üzerine etiket yapıştırılmış kutular gibidirler; kutunun içindeki içerik (değer) değişebilir, ancak kutunun adı (değişkenin adı) genellikle aynı kalır.

Python, modern, yüksek seviyeli ve yorumlamalı bir programlama dili olarak, değişken kullanımını son derece esnek ve sezgisel hale getirmiştir. Diğer bazı programlama dillerinin aksine, Python’da değişken tanımlarken veri tipini önceden belirtmenize gerek yoktur. Python’ın dinamik tipli yapısı sayesinde, bir değişkene atadığınız değerin tipi otomatik olarak algılanır. Bu özellik, kodu daha hızlı yazmanıza ve daha okunabilir hale getirmenize olanak tanır.

Bu makalede, Python 3’te değişkenlerin ne olduğunu, nasıl tanımlandığını, farklı veri tipleriyle nasıl kullanıldığını, değişkenlerin bellek yönetimiyle ilişkisini, kapsamlarını ve iyi kullanım pratiklerini detaylı bir şekilde inceleyeceğiz. Amacımız, Python’da değişkenleri etkili ve doğru bir şekilde kullanmanız için kapsamlı bir rehber sunmaktır.

Değişken Tanımlama ve Atama

Python’da bir değişken tanımlamak ve ona bir değer atamak oldukça basittir. Temel sözdizimi aşağıdaki gibidir:

değişken_adı = değer

Burada değişken_adı, değişkene verdiğiniz isimdir ve değer ise değişkende saklamak istediğiniz bilgidir. Eşittir (=) sembolü, “atama operatörü” olarak bilinir ve sağdaki değeri soldaki değişkene atar.

Örnekler:

# Bir tam sayı değeri atama
yas = 30

Bir metin (string) değeri atama
isim = "Ayşe"

Bir ondalıklı sayı (float) değeri atama
boy = 1.75

Bir boolean (mantıksal) değer atama
aktif_kullanici = True

Bir liste değeri atama
urunler = ["Elma", "Armut", "Muz"]

Değişkenleri ekrana yazdırma
print(yas)
print(isim)
print(boy)
print(aktif_kullanici)
print(urunler)

Değişken Adlandırma Kuralları ve Önerileri

Değişkenlere isim verirken belirli kurallara uymak ve genel kabul görmüş önerileri takip etmek önemlidir. Bu, kodunuzun başkaları (ve gelecekteki siz) tarafından daha kolay anlaşılmasını sağlar.

* Geçerli Karakterler: Değişken adları harfler (a-z, A-Z), rakamlar (0-9) ve alt çizgi (_) içerebilir.
* Başlangıç Karakteri: Değişken adları bir harf veya alt çizgi ile başlamalıdır. Bir rakamla başlayamaz.
* 1sayi = 10 (Hatalı)
* sayi1 = 10 (Doğru)
* _sayi = 10 (Doğru, ancak genellikle özel durumlar için kullanılır)
* Büyük/Küçük Harf Duyarlılığı: Python büyük/küçük harf duyarlıdır. Yani sayi, Sayi ve SAYI üç farklı değişkeni temsil eder.
* Ayrılmış Kelimeler (Keywords): Python’ın kendi içinde özel anlamları olan ve dilin yapısını oluşturan kelimeler (örneğin if, else, while, for, def, class, import, True, False, None vb.) değişken adı olarak kullanılamaz.
* PEP 8 Kuralları (Öneriler): Python kodlama stil rehberi olan PEP 8, değişken adları için aşağıdaki önerileri sunar:
* Küçük harf ve alt çizgi ile ayrılmış kelimeler kullanın (snake_case). Bu, okunabilirliği artırır.
* kullanici_adi = "Ali" (Önerilen)
* kullaniciAdi = "Ali" (CamelCase, bazı dillerde kullanılır, Python’da fonksiyonlar ve değişkenler için önerilmez)
* Sabitler (değeri program boyunca değişmeyecek değişkenler) için tüm harfleri büyük ve alt çizgi ile ayrılmış kelimeler kullanın.
* MAX_DENEME_SAYISI = 3
* Anlamlı isimler seçin. Değişkenin ne işe yaradığını açıkça belirten isimler kullanın. x veya temp gibi genel isimlerden kaçının, ancak döngü sayaçları gibi kısa ömürlü değişkenler için kabul edilebilir olabilirler.

Çoklu Atama

Python, tek bir satırda birden fazla değişkene değer atama yeteneği sunar. Bu, kodunuzu daha kısa ve öz hale getirebilir.

* Aynı Değeri Birden Fazla Değişkene Atama:

x = y = z = 100
    print(x, y, z) # Çıktı: 100 100 100

* Farklı Değerleri Birden Fazla Değişkene Atama:

ad, soyad, yas = "Ahmet", "Yılmaz", 25
    print(ad)    # Çıktı: Ahmet
    print(soyad)  # Çıktı: Yılmaz
    print(yas)   # Çıktı: 25

Bu yöntem, özellikle fonksiyonlardan birden fazla değer döndüğünde veya koleksiyonları açarken (unpacking) çok kullanışlıdır.

Değişkenlerin Yeniden Atanması (Reassignment)

Bir değişkene bir kez değer atadıktan sonra, programın ilerleyen aşamalarında bu değeri değiştirebilirsiniz. Python’ın dinamik tipli yapısı sayesinde, yeni atanan değerin farklı bir veri tipinde olması bile mümkündür.

mesaj = "Merhaba Dünya"
print(mesaj) # Çıktı: Merhaba Dünya

mesaj = "Python öğreniyorum" # Değeri değiştirildi
print(mesaj) # Çıktı: Python öğreniyorum

mesaj = 123 # Tipi de değiştirildi (string'den integer'a)
print(mesaj) # Çıktı: 123

Değişken Türleri (Veri Tipleri)

Python’da bir değişkene atadığınız her değerin bir tipi vardır. Python, bu tipleri otomatik olarak algılar ve yönetir. type() fonksiyonunu kullanarak bir değişkenin veya değerin tipini öğrenebilirsiniz.

sayi = 10
metin = "Python"
liste = [1, 2, 3]

print(type(sayi))  # Çıktı: 
print(type(metin)) # Çıktı: 
print(type(liste)) # Çıktı: 

Python’da en sık kullanılan yerleşik veri tiplerini inceleyelim:

Sayısal Tipler (Numeric Types)

Sayısal verileri temsil etmek için kullanılırlar.

* int (Tam Sayı): Pozitif veya negatif tam sayıları temsil eder. Python’daki int tipi, belleğinizin izin verdiği ölçüde sınırsız büyüklükte olabilir.

tam_sayi = 12345
    buyuk_sayi = 12345678901234567890
    print(type(tam_sayi))
    print(type(buyuk_sayi))

* float (Ondalıklı Sayı): Ondalıklı sayıları veya bilimsel gösterimdeki sayıları temsil eder.

ondalikli_sayi = 3.14
    bilimsel_sayi = 1.2e-5 # 0.000012 anlamına gelir
    print(type(ondalikli_sayi))
    print(type(bilimsel_sayi))

* complex (Karmaşık Sayı): Gerçek ve sanal kısımları olan karmaşık sayıları temsil eder. j veya J ile sanal kısım belirtilir.

karma_sayi = 3 + 4j
    print(type(karma_sayi))

Metin Tipi (String Type)

* str (Karakter Dizisi): Metinleri temsil eder. Tek tırnak ('...'), çift tırnak ("...") veya üçlü tırnak ('''...''' veya """...""") içine alınarak tanımlanır. Üçlü tırnaklar çok satırlı metinler için veya belge dizeleri (docstrings) için kullanılır.

tek_tirnak = 'Bu bir metindir.'
    cift_tirnak = "Bu da bir metindir."
    cok_satirli = """Bu
    çok
    satırlı bir metindir."""
    print(tek_tirnak)
    print(cok_satirli)

    # String birleştirme
    ad = "Ali"
    soyad = "Can"
    tam_ad = ad + " " + soyad
    print(tam_ad)

    # String tekrarı
    tekrar = "Merhaba " * 3
    print(tekrar) # Çıktı: Merhaba Merhaba Merhaba

Stringler değişmez (immutable) veri tipleridir; yani bir string oluşturulduktan sonra içeriği değiştirilemez. Değiştirmeye çalıştığınızda aslında yeni bir string oluşturulur.

Liste Tipi (List Type)

* list: Sıralı ve değiştirilebilir (mutable) eleman koleksiyonudur. Köşeli parantezler [] arasına virgülle ayrılarak tanımlanır. Farklı veri tiplerindeki elemanları içerebilir.

sayilar = [1, 2, 3, 4, 5]
    karisik_liste = ["Elma", 10, True, 3.14]
    print(sayilar[0]) # İlk elemana erişim (indeks 0'dan başlar)
    print(karisik_liste[2]) # Çıktı: True

    # Eleman ekleme
    sayilar.append(6)
    print(sayilar) # Çıktı: [1, 2, 3, 4, 5, 6]

    # Eleman değiştirme
    sayilar[0] = 100
    print(sayilar) # Çıktı: [100, 2, 3, 4, 5, 6]

Tuple Tipi (Tuple Type)

* tuple: Sıralı ve değiştirilemez (immutable) eleman koleksiyonudur. Parantezler () arasına virgülle ayrılarak tanımlanır. Listelere benzer ancak oluşturulduktan sonra elemanları değiştirilemez, eklenemez veya silinemez.

koordinatlar = (10, 20)
    renkler = ("kırmızı", "yeşil", "mavi")
    print(koordinatlar[0]) # Çıktı: 10

    # koordinatlar[0] = 30 # Hata verir: TypeError: 'tuple' object does not support item assignment

Tuple’lar, genellikle bir fonksiyonun birden fazla değer döndürmesi veya sabit veri koleksiyonları için kullanılır.

Küme Tipi (Set Type)

* set: Sırasız ve değiştirilebilir (mutable) benzersiz eleman koleksiyonudur. Süslü parantezler {} arasına virgülle ayrılarak tanımlanır. Tekrar eden elemanları otomatik olarak kaldırır.

benzersiz_sayilar = {1, 2, 3, 2, 1, 4}
    print(benzersiz_sayilar) # Çıktı: {1, 2, 3, 4} (Sıra garanti edilmez)

    # Eleman ekleme
    benzersiz_sayilar.add(5)
    print(benzersiz_sayilar)

    # Küme operasyonları
    set1 = {1, 2, 3}
    set2 = {3, 4, 5}
    print(set1.union(set2)) # Birleşim: {1, 2, 3, 4, 5}
    print(set1.intersection(set2)) # Kesişim: {3}

Sözlük Tipi (Dictionary Type)

* dict: Anahtar-değer çiftlerinden oluşan sırasız ve değiştirilebilir (mutable) bir koleksiyondur. Süslü parantezler {} arasına anahtar:değer şeklinde tanımlanır. Anahtarlar benzersiz olmalı ve genellikle string veya sayı gibi değiştirilemez tiplerden olmalıdır.

kullanici = {
        "ad": "Deniz",
        "soyad": "Kara",
        "yas": 28,
        "aktif": True
    }
    print(kullanici["ad"]) # Anahtar ile değere erişim: Çıktı: Deniz

    # Yeni anahtar-değer çifti ekleme
    kullanici["email"] = "deniz.kara@example.com"
    print(kullanici)

    # Değer güncelleme
    kullanici["yas"] = 29
    print(kullanici)

Boolean Tipi (Boolean Type)

* bool: Sadece iki değeri olabilen mantıksal bir veri tipidir: True veya False. Genellikle koşullu ifadelerde ve mantıksal operasyonlarda kullanılır.

dogru = True
    yanlis = False
    print(type(dogru)) # Çıktı: 

    if dogru:
        print("Bu ifade doğru.")

None Tipi (None Type)

* None: Bir değerin yokluğunu veya boş olduğunu temsil eden özel bir veri tipidir. Diğer dillerdeki null veya nil kavramına benzer.

bos_deger = None
    print(bos_deger)
    print(type(bos_deger)) # Çıktı: 

    if bos_deger is None:
        print("Değişkenin değeri yok.")

Değişken Kapsamı (Scope)

Değişken kapsamı, bir değişkenin programın hangi bölgelerinden erişilebilir olduğunu belirler. Python’da temel olarak üç ana kapsam düzeyi vardır: yerel (local), global ve iç içe fonksiyonların yerel kapsamı (enclosing). Python, değişken kapsamını LEGB kuralı (Local, Enclosing function locals, Global, Built-in) ile yönetir.

Yerel Kapsam (Local Scope)

Bir fonksiyon veya metod içinde tanımlanan değişkenler yerel kapsamdadır. Bu değişkenlere yalnızca tanımlandıkları fonksiyonun içinden erişilebilir. Fonksiyon sona erdiğinde, yerel değişkenler genellikle bellekten silinir.

def fonksiyon_ornegi():
    yerel_degisken = "Ben yerel bir değişkenim"
    print(yerel_degisken)

fonksiyon_ornegi()
print(yerel_degisken) # Hata verir: NameError: name 'yerel_degisken' is not defined

Global Kapsam (Global Scope)

Bir modülün (dosyanın) en üst seviyesinde, yani herhangi bir fonksiyonun veya sınıfın dışında tanımlanan değişkenler global kapsamdadır. Bu değişkenlere programın herhangi bir yerinden erişilebilir.

global_degisken = "Ben global bir değişkenim"

def baska_fonksiyon():
    print(global_degisken) # Global değişkene erişim

baska_fonksiyon()
print(global_degisken)

global Anahtar Kelimesi

Bir fonksiyon içinde global bir değişkenin değerini değiştirmek isterseniz, o değişkeni global anahtar kelimesiyle belirtmeniz gerekir. Aksi takdirde, Python fonksiyon içinde aynı isimde yeni bir yerel değişken oluşturur.

sayac = 0 # Global değişken

def artir():
    global sayac # Global sayac değişkenini kullanacağımızı belirtiyoruz
    sayac += 1
    print(f"Fonksiyon içi sayac: {sayac}")

print(f"Başlangıç sayac: {sayac}")
artir() # Fonksiyon içi sayac: 1
artir() # Fonksiyon içi sayac: 2
print(f"Fonksiyon dışı sayac: {sayac}") # Fonksiyon dışı sayac: 2

Eğer global sayac kullanmasaydık:

sayac = 0 # Global değişken

def artir_hatali():
    sayac = 0 # Yeni bir yerel 'sayac' değişkeni oluşturulur
    sayac += 1
    print(f"Fonksiyon içi sayac: {sayac}") # Her zaman 1 olur

print(f"Başlangıç sayac: {sayac}") # Başlangıç sayac: 0
artir_hatali() # Fonksiyon içi sayac: 1
artir_hatali() # Fonksiyon içi sayac: 1
print(f"Fonksiyon dışı sayac: {sayac}") # Fonksiyon dışı sayac: 0 (Global sayac değişmedi)

nonlocal Anahtar Kelimesi

İç içe (nested) fonksiyonlarda, dıştaki bir fonksiyonun yerel değişkenine içteki fonksiyondan erişmek ve onu değiştirmek için nonlocal anahtar kelimesi kullanılır. Bu, global kapsamdaki bir değişkeni değil, hemen dıştaki fonksiyonun yerel kapsamındaki bir değişkeni hedefler.

def dis_fonksiyon():
    mesaj = "Merhaba" # Dış fonksiyonun yerel değişkeni

    def ic_fonksiyon():
        nonlocal mesaj # Dış fonksiyonun 'mesaj' değişkenini kullanacağımızı belirtiyoruz
        mesaj = "Dünya"
        print(f"İç fonksiyon: {mesaj}")

    ic_fonksiyon()
    print(f"Dış fonksiyon: {mesaj}") # Çıktı: Dış fonksiyon: Dünya

dis_fonksiyon()

Değişkenlerin Bellekte Saklanması

Python’da değişkenler doğrudan değerleri tutmazlar; bunun yerine, bellek adreslerini (referanslarını) tutarlar. Bir değişken bir değere atandığında, Python bellekte o değer için bir nesne oluşturur ve değişken o nesneye referans eder.

id() fonksiyonu, bir nesnenin bellekteki benzersiz kimliğini (adresini) döndürür.

a = 10
b = 10
c = 20

print(id(a))
print(id(b))
print(id(c))

Yukarıdaki örnekte, a ve b aynı değere sahip olduğu için genellikle Python aynı bellek nesnesine referans etmelerini sağlar (küçük tam sayılar ve bazı stringler için optimizasyon). c farklı bir değere sahip olduğu için farklı bir bellek adresine sahip olacaktır.

Değişmez (Immutable) ve Değişebilir (Mutable) Tipler

Python’da veri tipleri iki ana kategoriye ayrılır:

* Değişmez (Immutable) Tipler: Bir kez oluşturulduktan sonra içeriği değiştirilemeyen nesnelerdir. Eğer bir immutable değişkene yeni bir değer atarsanız, aslında bellekte yeni bir nesne oluşturulur ve değişken bu yeni nesneye referans etmeye başlar.
* Örnekler: int, float, str, tuple, bool, NoneType.

x = 10
    print(id(x)) # Bellek adresi 1

    x = x + 1 # x'in değeri 11 oldu
    print(id(x)) # Bellek adresi 2 (Yeni bir int nesnesi oluşturuldu)

    s = "hello"
    print(id(s)) # Bellek adresi 3

    s = s + " world" # s'in değeri "hello world" oldu
    print(id(s)) # Bellek adresi 4 (Yeni bir str nesnesi oluşturuldu)

* Değişebilir (Mutable) Tipler: Bir kez oluşturulduktan sonra içeriği değiştirilebilen nesnelerdir. Bir mutable değişkenin içeriğini değiştirdiğinizde, değişkenin referans ettiği bellek adresi genellikle aynı kalır, sadece o adresteki nesnenin içeriği değişir.
* Örnekler: list, dict, set.

liste = [1, 2, 3]
    print(id(liste)) # Bellek adresi 1

    liste.append(4) # Listeye yeni eleman eklendi
    print(id(liste)) # Bellek adresi hala 1 (Nesnenin içeriği değişti)
    print(liste) # Çıktı: [1, 2, 3, 4]

    liste2 = liste # liste2, liste ile aynı nesneye referans eder
    liste2.append(5)
    print(liste) # Çıktı: [1, 2, 3, 4, 5] (liste de değişti!)

Mutable tiplerle çalışırken bu referanslama davranışı önemlidir. Özellikle fonksiyonlara mutable nesneler geçirdiğinizde veya bir listeyi başka bir listeye atadığınızda dikkatli olunmalıdır, çünkü beklenmedik yan etkilere yol açabilir. Eğer mutable bir nesnenin kopyasını oluşturmak istiyorsanız, list.copy(), dict.copy() veya dilimleme ([:]) gibi yöntemleri kullanmalısınız.

Operatörler ve Değişkenler

Değişkenler üzerinde çeşitli işlemler yapmak için operatörler kullanılır.

Aritmetik Operatörler: +, -, , / (bölme, float sonuç), // (tam sayı bölme), % (mod alma), (üssü).

a = 10
    b = 3
    print(a + b) # 13
    print(a / b) # 3.333...
    print(a // b) # 3
    print(a % b) # 1
    print(a  b) # 1000

Atama Operatörleri: = (atama), +=, -=, =, /=, %=, =, //= (kısa yazım).

x = 5
    x += 3 # x = x + 3 yani x = 8
    print(x)

* Karşılaştırma Operatörleri: == (eşit mi), != (eşit değil mi), > (büyük mü), < (küçük mü), >= (büyük veya eşit mi), <= (küçük veya eşit mi). Sonuçları True veya False olan boolean değerlerdir.

print(5 == 5) # True
    print(5 != 10) # True
    print(10 > 5) # True

* Mantıksal Operatörler: and, or, not. Boolean değerler üzerinde mantıksal işlemler yapar.

print(True and False) # False
    print(True or False)  # True
    print(not True)       # False

* Kimlik Operatörleri: is, is not. İki değişkenin aynı bellek nesnesine mi referans ettiğini kontrol eder (değerlerinin aynı olup olmadığını değil).

liste1 = [1, 2, 3]
    liste2 = [1, 2, 3]
    liste3 = liste1

    print(liste1 == liste2) # True (değerleri aynı)
    print(liste1 is liste2) # False (farklı bellek nesneleri)
    print(liste1 is liste3) # True (aynı bellek nesnesi)

* Üyelik Operatörleri: in, not in. Bir değerin bir koleksiyon (liste, tuple, string, set, dictionary anahtarları) içinde olup olmadığını kontrol eder.

meyveler = ["elma", "armut", "kiraz"]
    print("elma" in meyveler)    # True
    print("muz" not in meyveler) # True

İyi Değişken Kullanımı Pratikleri

Temiz ve sürdürülebilir kod yazmak için iyi değişken kullanım pratiklerini benimsemek çok önemlidir.

* Anlamlı İsimler Kullanın: Değişkenin amacını ve tuttuğu veriyi açıkça belirten isimler seçin. x, y, temp gibi genel isimlerden kaçının, ancak basit döngü sayaçları (i, j) gibi kısa ömürlü değişkenler için kabul edilebilir olabilirler.
* Kötü: a = 100
* İyi: maksimum_hiz = 100
* PEP 8 Kurallarına Uyun: Python topluluğunun kabul ettiği adlandırma standartlarını (snake_case) takip edin. Bu, kodunuzun tutarlı ve okunabilir olmasını sağlar.
* Sabitleri Büyük Harfle Yazın: Değeri program boyunca değişmeyecek olan sabitler için tüm harfleri büyük ve kelimeler arasına alt çizgi koyarak adlandırın. Bu, kodunuzu okuyanlara o değerin bir sabit olduğunu görsel olarak belirtir.
* PI = 3.14159
* VERGI_ORANI = 0.18
* Gereksiz Değişkenlerden Kaçının: Her zaman bir değişkene ihtiyaç duyup duymadığınızı düşünün. Bazen bir ifadeyi doğrudan kullanmak, ara bir değişkene atamaktan daha temiz olabilir.
* Kapsamı Dar Tutun: Mümkün olduğunca değişkenleri en dar kapsamda tanımlayın (yani yerel değişkenleri tercih edin). Global değişkenler, kodun beklenmedik yerlerde değişmesine neden olabileceği için hata ayıklamayı zorlaştırabilir.
* Değişkeni Tanımlamadan Kullanmayın: Python, tanımlanmamış bir değişkene erişmeye çalıştığınızda NameError hatası verir. Her zaman bir değişkene değer atamadan önce onu kullanmadığınızdan emin olun.

Sonuç

Python 3'te değişkenler, herhangi bir programın temel yapı taşlarıdır. Verileri depolamamızı, işlememizi ve program akışını kontrol etmemizi sağlarlar. Python'ın dinamik tipli yapısı, değişken tanımlamayı son derece esnek hale getirirken, mutable ve immutable tipler arasındaki farkı anlamak, bellek yönetimi ve program davranışını doğru bir şekilde kavramak için kritik öneme sahiptir.

Bu makalede ele aldığımız gibi, değişken adlandırma kurallarına uymak, kapsamlarını doğru anlamak ve iyi pratikleri uygulamak, sadece çalışan değil, aynı zamanda okunabilir, sürdürülebilir ve hata ayıklaması kolay kodlar yazmanıza yardımcı olacaktır. Python'da ustalaşmanın yolu, değişkenleri ve onların nasıl çalıştığını derinlemesine anlamaktan geçer. Bu bilgilerle, daha karmaşık veri yapılarını ve algoritmaları güvenle uygulayabilir, Python yolculuğunuzda sağlam bir temel oluşturabilirsiniz.