Python Değişken Kapsamı (Scope)
Ders 26: Return, Varsayılan Değerler, args ve *kwargs dersinde fonksiyonların değer üretmesini ve parametre esnekliğini gördük. Şimdi sıra başka bir temel soruda: değişkenler nerede yaşar? Fonksiyonun içindeki bir isimle dışarıdaki bir isim aynı değişken mi, farklı mı? Bu dersin cevabı, ileride karşılaşacağınız en kafa karıştırıcı hataların da anahtarı. Dürüst olayım: scope kurallarını kavramadan Python yazmak, ışıksız bir odada mobilya dizmeye benzer; her şey yerinde görünür, ta ki bir yere takılana kadar.
Fonksiyonun İçi Ayrı Bir Dünya
Bir fonksiyonun içinde tanımlanan değişken yerel (local) değişkendir. Yalnızca o fonksiyonun çalıştığı süre boyunca yaşar. Fonksiyonun dışında tanımlanan değişken ise global kapsamdadır; dosyanın her yerinden erişilebilir.
mesaj = "Dışarıdayım" # global değişken
def goster():
mesaj = "İçerideyim" # yerel değişken; global'i gölgeler
print(mesaj)
goster() # İçerideyim
print(mesaj) # Dışarıdayım
Arkada olan şu: fonksiyon içindeki atama, mesaj isminde yeni bir yerel değişken yarattı; dışarıdaki mesaj'a hiç dokunulmadı. Fonksiyon bitince yerel mesaj bellekten silindi ve global mesaj eski değeriyle kaldı. İki değişken aynı ismi taşıyor ama farklı kutularda duruyorlar.
Bu kuralın güzel yanı, fonksiyonların birbirinden izole çalışması. Bir fonksiyonun içindeki sayaç değişkeni, başka fonksiyonun içindeki aynı isimli değişkeni asla etkilemez:
def islem_yap():
toplam = 100 # bu fonksiyonun kendi yerel değişkeni
toplam += 50
return toplam
def baska_islem():
toplam = 5 # bambaşka bir kutu
return toplam
print(islem_yap()) # 150
print(baska_islem()) # 5
Her iki fonksiyon da kendi toplam kutusunu yarattı ve birbirinden tamamen habersiz çalıştı. Python isimleri böyle izole tutarak binlerce satırlık projelerde bile değişken çakışmalarının önüne geçer. Bu izolasyon, fonksiyonların "kendi dünyası" dediğimiz şeydir.
Fonksiyon Dış Değişkeni Okuyabilir
Yerel değişkenler izoledir ama fonksiyonlar dışarıdaki global değişkenleri okuyabilir:
VERGI_ORANI = 0.20 # global sabit
def vergi_hesapla(tutar):
# global değişkeni okumak serbest
return tutar * VERGI_ORANI
print(vergi_hesapla(1000)) # 200.0
Python, fonksiyon içinde VERGI_ORANI'yi bulamayınca bir üst kapsama, yani global alana baktı ve orada buldu. Okuma işlemi için bu tamamen serbest. Sabitler ve yapılandırma değerleri bu yüzden rahatça global tanımlanır; fonksiyonlar onları okuyarak kullanır.
Ama dikkat: okumak serbest, değiştirmek değil. Ve işte bu noktada Python'un en meşhur hatası sahneye çıkıyor.
UnboundLocalError: Okudum, Değiştiremem
Bir fonksiyonun içinde global bir değişkene yeni değer atamaya kalkarsanız, Python o ismi yerel kabul eder. Sonra o ismi atamadan önce okumaya çalışırsanız patlarsınız:
sayac = 0 # global sayaç
def artir():
sayac += 1 # HATA: UnboundLocalError
return sayac
artir()
Bunun arkasında ne var? sayac += 1 ifadesi bir atama içerdiği için Python, sayac'ı fonksiyonun yerel değişkeni ilan etti. Ama sağ taraftaki sayac + 1'i hesaplarken yerel sayac henüz tanımlanmamıştı; ortada okunacak bir değer yoktu. Python da "local variable 'sayac' referenced before assignment" diye bağırdı.
Bunu ilk kez bir stajyerde canlı izledim. Genç arkadaş, site ziyaret sayacını tutan bir fonksiyon yazmıştı; kod iki saattir çalışmıyor, her denemede aynı hata ekrana düşüyordu. "Değişken dışarıda tanımlı, neden bulamıyor?" diye sormuştu. Sorun, değişkenin bulunamaması değildi; Python'ın onu yerel sanmasıydı. O gün anladım ki bu hata, scope kurallarını bilmeyen herkesin ilk büyük duvarı.
Bir de şu var: atamanın fonksiyonun neresinde olduğu önemli değildir. Python, fonksiyonun tamamını önceden tarar ve içinde atama geçen her ismi yerel ilan eder:
seviye = 5 # global
def kontrol():
print(seviye) # HATA! aşağıdaki atama yüzünden
seviye = 10 # Python bu yüzden seviye'yi yerel saydı
kontrol()
Atama, okumanın altında olsa bile seviye baştan yerel kabul edildi. Bu yüzden daha ilk print satırı, tanımlanmamış bir yerel değişkeni okumaya çalışınca UnboundLocalError fırlattı. Kural nettir: bir isme fonksiyonun herhangi bir yerinde atama yapıyorsanız, o isim o fonksiyonun tamamında yereldir.
Yerinde Değişiklik Ayrı Bir Durum
Atama yasak ama global bir listenin içeriğini değiştirmek atama sayılmaz; o yüzden çalışır:
kayitlar = [] # global liste
def kayit_ekle(isim):
# atama yok; nesnenin içeriğini değiştiriyoruz
kayitlar.append(isim)
kayit_ekle("Ali")
kayit_ekle("Veli")
print(kayitlar) # ['Ali', 'Veli']
Burada kayitlar ismine yeni bir değer atanmadı; yalnızca o ismin işaret ettiği liste nesnesinin içeriği büyütüldü. Python bunu atama saymadığı için global aramaya izin verdi. Çalışıyor diye sevinmeyin: fonksiyon yine dışarıya görünmez bir yan etki bırakıyor ve global değişkenin taşıdığı tüm riskleri miras alıyor. Ben burada bile parametre alıp return etmeyi tercih ederim.
global Anahtar Kelimesi
İlle de dışarıdaki değişkeni değiştirecekseniz, onu fonksiyon içinde global ile bildirirsiniz:
sayac = 0
def artir():
global sayac # "dışarıdaki sayac'ı kullanıyorum" de
sayac += 1
return sayac
print(artir()) # 1
print(artir()) # 2
print(sayac) # 2
global bildirimi, Python'a "bu isim için yerel değişken yaratma, dışarıdakini kullan" der. Böylece artırma işlemi gerçek global sayac üzerinde yapıldı ve değişiklik fonksiyon dışından da görüldü. Kod çalışıyor; ama size dürüst tavsiyem, bu kapıyı sık açmayın.
Neden az kullanmalı? Üç somut sebep var:
- Global değişkeni değiştiren fonksiyonlar görünmez bağımlılıklar üretir; kimin neyi ne zaman değiştirdiği belli olmaz.
- Fonksiyonun davranışı parametrelerine değil, programın o anki durumuna bağlanır; aynı girdi farklı anlarda farklı sonuç verebilir.
- Hata ayıklama kabusa döner: aynı değişkeni beş fonksiyon değiştiriyorsa bozanı bulmak saatler alır.
Bu saatleri ben harcadım. Üç yıl önce devraldığım bir projede sekiz farklı fonksiyon aynı global toplam değişkenini değiştiriyordu; biri bir yerde sıfırlamayı unutmuş, muhasebe raporları ayda bir tutarsız çıkıyordu. Hatayı bulmak dört günümü aldı çünkü değişkenin hangi fonksiyonda bozulduğunu kestirmenin yolu yoktu. O projeden sonra global kullanımını yalnızca "gerçekten başka çare yok" durumlarına sakladım.
LEGB Kuralı (Kısa)
Python bir ismi dört kapsamda, belirli bir sırayla arar: Local (fonksiyon içi), Enclosing (iç içe fonksiyonlarda dış fonksiyon), Global (modül seviyesi), Built-in (Python'un kendi isimleri). İlk bulduğu yerde durur.
uzunluk = "global" # G kapsamı
def dis_fonksiyon():
uzunluk = "enclosing" # E kapsamı
def ic_fonksiyon():
uzunluk = "local" # L kapsamı
print(uzunluk)
ic_fonksiyon()
dis_fonksiyon() # local
Python önce iç fonksiyonda aradı ve buldu: local. Aramayı orada kesti. Eğer local'de olmasaydı sırayla enclosing, global ve built-in'e bakacaktı. LEGB budur; dört harflik bir arama sırası. Bu yüzden print gibi isimler tanımlamasanız bile çalışır, çünkü onlar built-in kapsamında durur.
Doğru Desen: Parametre Al, Return ile Geri Ver
Global değişkeni değiştirmek yerine, değeri parametre olarak alıp yeni hâlini return ile geri vermek neredeyse her zaman daha iyidir:
def artir(sayac):
# sayac'ı parametre olarak al, yeni değeri döndür
return sayac + 1
sayac = 0
sayac = artir(sayac) # dönen değeri tekrar sayac'a ata
sayac = artir(sayac)
print(sayac) # 2
Fonksiyon dış dünyaya hiç dokunmadı; yalnızca verilen değere 1 ekleyip geri verdi. Güncelleme sorumluluğu çağıran tarafta kaldı ve sayac'ın hangi satırda değiştiği açıkça görülüyor. Aynı fonksiyonu istediğiniz on farklı sayaçla, hiçbir çakışma korkusu olmadan kullanabilirsiniz.
Bu desenin bir başka güzelliği de test edilebilirlik. Parametre alıp değer dönen bir fonksiyonu tek başına çağırıp sonucunu kontrol edebilirsiniz:
# aynı fonksiyon, farklı başlangıç değerleriyle bağımsız çalışır
print(artir(10)) # 11
print(artir(99)) # 100
Hiçbir global ayar gerekmeden fonksiyon her girdi için aynı davranışı sergiledi. Bu tür fonksiyonlara "saf fonksiyon" denir ve yazılımda ne kadar çok saf fonksiyonunuz varsa hayatınız o kadar kolaydır. Test yazarken dünyanın durumunu hazırlamak zorunda kalmazsınız; fonksiyona girdiyi verir, çıktıyı denetlersiniz.
Aynı İsimli Yerel/Global Değişken Karmaşası
Aynı ismi hem yerelde hem globalde kullanmak Python'da yasak değildir; ama kafa karışıklığının da kralıdır. İşte klasik senaryo:
durum = "aktif" # global
def islem():
durum = "pasif" # yerel; global'i gölgeliyor
print(durum)
islem() # pasif
print(durum) # aktif
Fonksiyon içindeki atama, yeni bir yerel durum yarattı ve global olanı gölgeledi. Fonksiyon bittiğinde yerel kutu çöpe gitti; global durum "aktif" olarak kaldı. Kod çalıştı, hata yok, ama okuyan kişi iki farklı değişkenin tek isimle dans ettiğini bilmezse yanlış sonuçlar çıkarır.
Bu gölgeleme, özellikle uzun fonksiyonlarda sinsidir. Fonksiyonun üstünde globali okuyor, altında aynı isimli yereli değiştiriyorsanız, ortada kimin ne olduğunu takip etmek kabusa döner. Tavsiyem net: yerel değişkenlere global isimlerden farklı, anlamlı isimler verin.
KULLANICI_DURUMU = "aktif" # global sabit, büyük harfle
def islem():
yeni_durum = "pasif" # farklı ve açıklayıcı bir isim
print(yeni_durum)
islem() # pasif
print(KULLANICI_DURUMU) # aktif
Burada global sabit BÜYÜK HARFLE, yerel değişken ayrı bir isimle yazıldı. Hangisinin ne olduğu tek bakışta belli; gölgeleme ihtimali baştan ortadan kalktı. Büyük harf geleneği, Python topluluğunda global sabitleri işaretlemenin yaygın yoludur.
Sık Sorulan Sorular
Fonksiyonum global değişkeni okuyamıyor, ne yapmalıyım?
Değişkeni yalnızca okuyorsanız sorun yoktur; Python kendisi global kapsama bakar. Hata alıyorsanız büyük olasılıkla değişkene atama veya += gibi bir işlem yapıyorsunuzdur ve Python onu yerel sanıyordur. Değeri parametre olarak almak en temiz çözümdür.
global kullanmak kötü mü?
Tek başına yasak değil ama risklidir. Global durumu değiştiren fonksiyonlar görünmez bağımlılıklar yaratır ve hata ayıklamayı zorlaştırır. Değeri parametre alıp return ile geri vermek, çoğu durumda daha okunur ve daha güvenli bir desendir.
Aynı isimli yerel ve global değişken kullanabilir miyim?
Kullanabilirsiniz ama önermem. Yerel değişken globali gölgeler ve kodun hangi bölümünde hangi kutuya eriştiğinizi takip etmek zorlaşır. Farklı ve açıklayıcı isimler seçmek her zaman kazandırır.
Sırada Ne Var?
Scope kurallarını artık biliyorsunuz: değişkenlerin nerede yaşadığını, ne zaman gölgelendiğini ve global kullanmanın bedelini. Sıradaki derste fonksiyonların daha kısa ve anonim bir akrabasıyla tanışacağız. Lambda, map, filter dersinde tek satırlık fonksiyonlar yazacak ve onları liste işlemlerinde nasıl kullanacağımızı göreceğiz.



