Python Programlama Dili

Bölüm 1

Başlangıç Bilgileri

Top Navigasyon

Ders 10

1.19 - Python Kapsam ve İsim Alanları

Python programlama dilinde, üç türlü kapsam alanı gerçekleşebilir. Bunlar,

olarak tanımlanırlar.

Her programda bu üç kapsam alanının oluşmuş olması zorunlu değildir. Program çalışınca ilk olarak global kapsam alanı oluşur ve bu global kapsam alanına builtins modülü otomatik olarak import edilir. Bunun sonucunda, global kapsam alanına kalıtımla önemli sayıda, gerekli program öğeleri yerleştirilmiş olur.

Eğer bir programda, fonksiyon tanımı yapılmamışsa, herhangibir yerel kapsam alanı oluşmaz, programda sadece global kapsam alanı geçerli olur.

Bir programda, yerel bir kapsam alanı açılmış olsun. Bir program öğesi yerel bir kapsam alanından çağrılmışsa, Python derleyicisi bu öğeyi önce çağrılmış olduğu yerel kapsam alanında arar. Bulamazsa, önce global kapsam alanında, sonra da builtins kapsam alanında arar. Bulamazsa bir NameError istisnası oluşur (hata), program durur ve NameError mesajı görüntülenir.

İsim alanları (namespaces), bir program öğesinin tanımlı olduğu nesneyi beliritir. Her modül bir nesnedir ve programa import edilen her modül, kendi özel isim alanına sahiptir. Bir modülde tanımlı bir program öğesine erişebilmek için, önce modülün erişebilir olması, yani ya varsayılan builtins (__builtins__) modülü olması veya programa import edilmiş olması gerekir.

Global isim alanı, builtins modülünün tüm öğelerine kalıtımla sahip olur. Bu program öğelerine yeni tanımlanmış her fonksiyon veya tek değer ile, global isim alanına bir özellik (değer veya metot olarak) eklenmiş olur.

Buitins modülü ile, global isim alanının kalıtımla sahip olduğu özellikler, aşağıdaki gibi saptanabilir. 

>>>__builtins__.__dict__
Out[28]: 
{'ReferenceError': ReferenceError,
 'NotADirectoryError': NotADirectoryError,
 'NameError': NameError,
 'dict': dict,
 'IsADirectoryError': IsADirectoryError,
 'globals': ,
 'issubclass': ,
 'ord': ,
 'AttributeError': AttributeError,
 '__IPYTHON__': True,
 'license': Type license() to see the full license text,
 '__build_class__': ,
 'TypeError': TypeError,
 'locals': ,
 'callable': ,
 '__IPYTHON__active': 'Deprecated, check for __IPYTHON__',
 'type': type,
 '__spec__': ModuleSpec(name='builtins', loader=),
 'any': ,
 'enumerate': enumerate,
 'abs': ,
 'TabError': TabError,
 'iter': ,
 'all': ,
 'IOError': OSError,
 'True': True,
 'DeprecationWarning': DeprecationWarning,
 'classmethod': classmethod,
 '__name__': 'builtins',
 'hex': ,
 'divmod': ,
 'range': range,
 'SystemError': SystemError,
 'exec': ,
 'len': ,
 'UnicodeTranslateError': UnicodeTranslateError,
 'next': ,
 'sum': ,
 'Exception': Exception,
 '__debug__': True,
 'FloatingPointError': FloatingPointError,
 'staticmethod': staticmethod,
 'FutureWarning': FutureWarning,
 'BufferError': BufferError,
 'object': object,
 'ascii': ,
 'sorted': ,
 'UnicodeError': UnicodeError,
 'UnboundLocalError': UnboundLocalError,
 'ConnectionRefusedError': ConnectionRefusedError,
 'BytesWarning': BytesWarning,
 'bytes': bytes,
 'super': super,
 'None': None,
 'float': float,
 'SyntaxWarning': SyntaxWarning,
 'runfile': ,
 'UnicodeWarning': UnicodeWarning,
 'ValueError': ValueError,
 'credits':     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
     for supporting Python development.  See www.python.org for more information.,
 'Ellipsis': Ellipsis,
 'FileExistsError': FileExistsError,
 'BaseException': BaseException,
 '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.",
 'UnicodeEncodeError': UnicodeEncodeError,
 'dreload': ,
 'StopIteration': StopIteration,
 'bin': ,
 'BrokenPipeError': BrokenPipeError,
 'zip': zip,
 'RuntimeError': RuntimeError,
 'hash': ,
 'False': False,
 'MemoryError': MemoryError,
 'KeyError': KeyError,
 'NotImplementedError': NotImplementedError,
 'max': ,
 'ImportWarning': ImportWarning,
 'RuntimeWarning': RuntimeWarning,
 'set': set,
 'NotImplemented': NotImplemented,
 'WindowsError': OSError,
 'repr': ,
 'TimeoutError': TimeoutError,
 'IndexError': IndexError,
 'isinstance': ,
 'hasattr': ,
 'open': ,
 'EOFError': EOFError,
 'copyright': Copyright (c) 2001-2014 Python Software Foundation.
 All Rights Reserved.
 
 Copyright (c) 2000 BeOpen.com.
 All Rights Reserved.
 
 Copyright (c) 1995-2001 Corporation for National Research Initiatives.
 All Rights Reserved.
 
 Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
 All Rights Reserved.,
 'reversed': reversed,
 'dir': ,
 'ZeroDivisionError': ZeroDivisionError,
 'print': ,
 '__loader__': _frozen_importlib.BuiltinImporter,
 'OverflowError': OverflowError,
 'tuple': tuple,
 'min': ,
 'map': map,
 'compile': ,
 'help': Type help() for interactive help, or help(object) for help about object.,
 'SystemExit': SystemExit,
 'FileNotFoundError': FileNotFoundError,
 'ChildProcessError': ChildProcessError,
 'ImportError': ImportError,
 'getattr': ,
 'PermissionError': PermissionError,
 'input': ,
 'ArithmeticError': ArithmeticError,
 'complex': complex,
 'UserWarning': UserWarning,
 'setattr': ,
 'ResourceWarning': ResourceWarning,
 'ProcessLookupError': ProcessLookupError,
 'OSError': OSError,
 'memoryview': memoryview,
 'Warning': Warning,
 'str': str,
 'bool': bool,
 'filter': filter,
 'LookupError': LookupError,
 'get_ipython': >,
 'frozenset': frozenset,
 'eval': ,
 'chr': ,
 'UnicodeDecodeError': UnicodeDecodeError,
 'EnvironmentError': OSError,
 'ConnectionError': ConnectionError,
 'AssertionError': AssertionError,
 'int': int,
 'bytearray': bytearray,
 'id': ,
 'SyntaxError': SyntaxError,
 'format': ,
 'BlockingIOError': BlockingIOError,
 'property': property,
 '__import__': ,
 'GeneratorExit': GeneratorExit,
 'PendingDeprecationWarning': PendingDeprecationWarning,
 '__package__': '',
 'oct': ,
 'ConnectionResetError': ConnectionResetError,
 'vars': ,
 'pow': ,
 'round': ,
 'slice': slice,
 'list': list,
 'execfile': ,
 'InterruptedError': InterruptedError,
 'ConnectionAbortedError': ConnectionAbortedError,
 'KeyboardInterrupt': KeyboardInterrupt,
 'delattr': ,
 'IndentationError': IndentationError}

Bu kalıtımla intikal eden özellikler üzerinde daha detaylı bilgi almak istersek, chevron üzerinden, 

>>>__builtins__.help(pow);

yazılabilir. Fakat, builtins modülü global isim alanına tüm özelliklerine otomatik olarak eksport etmiştir. Bu özellikler artık global isim alanın da özellikleridir. Global isim alanında tanımlı özelliklere ise, herhangibir isim alanı adı verilerek erişilmez. Özelliğin adını vermek yeterli olur. Bu durumda, ek bilgiler, 

>>>help(pow);enter

Help on built-in function pow in module builtins:

pow(...)
    pow(x, y[, z]) -> number
    
    With two arguments, equivalent to x**y.  With three arguments,
    equivalent to (x**y) % z, but may be more efficient (e.g. for ints).

bilgisi elde edilir.

Global isim alanından her özelliğe erişim olanağı yoktur. İsim alanı bir kapsam alanı değildir, sadece bir erişim kodudur. Eğer global isim alanı içinde yeni bir fonksiyon tanımlanmış ve bu fonksiyon içinde, bir tanıtıcıya bir değer bağlanmışsa, bu bir yerel program öğesidir ve global isim alanından buna hiçbir şekilde erişim olanağı yoktur. Sadece, eğer değer bağlanması sırasında bu tanıtıcının global olacağı açıkça belirtilmişse, bu tanıtıcı, global isim alanından çağrılabilir. Aynı şekilde, global isim alanında bir yeni nesne (object) tanımlanmışsa, global isim alanından erişilebilecek yeni bir isim alanı tanımlanmış demektir. Global isim alanından, bu yeni isim alanında tanımlı özelliklere erişim sağlayabilmek için, yeni isim alanını önek olarak belirtmek gerekir.

Bir programda builtins modülü otomatik olarak import edilyor. Bu modül tarafından, yukarıda görülen export edilen özellikler incelenerek, global isim alanında aynı özellikleri yeniden tanımlamamak gerekiyor. Eğer amaç bu değilse, eski tanım kaybolacak ve yeni tenım geçerli olacağından, bindirme (üstüne çıkma) (overriding) denilen bu gibi tanımlardan kaçınmak gerekir. Bu uyarı, import edilen her modülün export ettiği özellikler için de geçerlidir.

1.19.1 - Değişkenler

Bir tanıtıcının değeri, program boyunca değişebilirse bu tanıtıcıya bir değişken (variable) adı verilir. Değişkenler erişilebilirliklerine göre global veya yerel (lokal) değişkenler olabilir.

1.19.1.1 - Global Değişkenler

Global değişkenler, global kapsam alanında tanımlı ve erişilebilen değişkenlerdir. Global değişkenler, global program alanında doğrudan tanımlanabilecekleri gibi, global alanda tanımlı bir fonksiyon içinden global a = 18; şeklinde de tanımlanabilirler. Global bir değişkene, global isim alanında tanımlı her fonksiyon veya her nesne içinden erişilebilir ve değeri değiştirilebilir. Bu nedenle global değişken kullanımı sakıncalıdır. En azından, çok dikkatli kullanılması gerekir. Çünkü, programın bir yerinde tanımlanan ve değeri belirlenen bir global değişkenin değeri, en kısa ve kolay izlenebilien programlarda bile, programcı farkında olmadan değişebilir ve programın ilerideki adımlarında çağrıldığında beklenenden çok farklı değerler döndürebilir. Aşağıdaki program, global bir değişenin kullanımı ve tanımının değişmesini açıklamaktadır. 

# Program : Ders10program1.py

a = [12, 14, 16]; # Global Değişken

def ekle (g):
    
g.append(89);
print ("g = " , g);
return g;

ekle (a);

print('a = ' , a);


---------Program----Sonucunun----Görüntülenmesi----------------------------

g =  [12, 14, 16, 89]
a =  [12, 14, 16, 89]

Yukarıdaki programda dikkat edilecek birçok konu bulunmaktadır.

Yukarıdaki programın sağlamış olduğu bilginin sonucu olarak, bir program dilinde ne global değişken tanımı, ne de global alanda program adımları uygulanması güvenli bir program stili değildir ve profesyonel olarak asla global alanda çalışma uygulanmaz. Bilgiler, özel fonksiyonlarda geliştirilir ve fonksiyonların birbirlerini çağırması ile aktarılır. Python programlama dilinde özel bir __name__ değişkeni, değeri "main" olacak şekilde öntanımlı olarak sağlanmıştır. Tüm fonksiyonlar, bu ana fonksiyonun içinden çağrılır ve bilgi iletişimi sorunsuz olarak sağlanır. Bunu yerel değişkenleri inceleyeceğimiz bir sonraki konuda göreceğiz.

1.19.1.2 - Yerel Değişkenler

Yerel değişkenler, fomksiyonların içinde tanımlanan ve global çalışma alanından erişilemeyen değişkenlerdir. Bu konudaki bir uygulama, aşağıda görülmektedir. 

# Program : Ders10program2.py

def main():

print('Ilk Deger = ' , defineList());

print('En Guncel Deger = ' , updatedList(appendList(defineList(),678));

def defineList():
__a = [23,78,99];
return __a;

def appendList(q, y):
q.append(y);
return q;

def updatedList(last):
updatedState = last;
return updatedState;

if __name__ == '__main__':
main();


---------Program----Sonucunun----Görüntülenmesi----------------------------

Ilk Değer =  [23, 78, 99]
En Güncel Değer =  [23, 78, 99, 678]

Yukarıdaki programın incelenmesini, ilk olarak tanımlanmış fonksiyonları inceleyerek başlayalım.

Burada defineList() fonksiyonu, hiçbir argüman almıyor. Bu fonksiyonun içinde bir __a değişkeni tanımlanıyor ve bu yerel değişkene, bir liste literali atanıyor. Fonksiyon bu yerel değişkenin değerini döndürüyor. Bu fonksiyon içinde tanımlanmış olan __a değişkeni, yerel bir değişkendir. Bu değişkene sadece tanımlanmış olduğu fonksiyon içinden erişilebilir. Bu fonksiyon dışından hiçbir şekilde, bu fonksiyonun yerel değişkenlerine erişilemez. Bu nedenle, yerel __a değişkeni, değerinin değişmesine karşı tam olarak korunaklı bir değişkendir. Değeri ancak tanımlandığı fonksiyon içinden değiştirilebilir.

Program içinde tanımlanmış olan appendList(q, y) fonksiyonu, q ve y olarak iki formal değişken alacak şekilde tanımlanmıştır. Formal değişkenlerden ilki bir liste tipi değerdir ikincisi ise, her değeri alabilir,çünkü bir listeye son eleman olarak eklenecektir. Bu fonksiyon içinde bir yerel değişken tanımlanmamıştır.

Bir diğer fonksiyon, updatedList(last) fonksiyonudur. Bu fonksiyonun formal parametresi last değişkeni, liste tipi bir değişkendir. Bu fonksiyon içinde tanımlanmış olan, updatedState değişkeni, bir yerel değişkendir. Fonksiyon bu yerel değişkenin değerini döndürmektedir.

Global alanda, çağrılmış olan __name__ değişkeni, global alana otomatik olarak import edilen builtins modülünde, değeri, '__main__' olarak tanımlanmış bir modül düzeyi değişkenidir. Burada ismi, tanımlı değerine karşı sınanarak, eğer sonuç doğru ise, main() ana fonksiyonun çağrılması bildirilmiştir. Aslında global alandan main() fonksiyonu, doğrudan doğruya main() olarak çağrılabilirdi, fakat burada amaç, herşeyin düzgün gittiğini, builtins maodülünün sorunsuzca indirilmiş olduğunun sınanmasıdır. Bunun için, bu dolaylı yola başvurulmuştur.

Programda ana fonksiyon olarak, tasarlanmış olan main() fonksiyonu, prensip olarak, ne argüman gerektiren, ne de herhangibir değer döndürmeyen bir fonksiyondur. Bu fonksiyon içinde, yerel değişken tanımlanabilir. Fakat, aynı global değişkenlerde olduğu gibi programcı farkında olmadan değerinin değişmesi olasılığı bulunmaktadır, çünkü, ana fonksiyon, programdaki tüm fonksiyonların çağrıldığı ve birbirlerine değer aktardıkları, bir iletişim alanıdır. İletişim amacı ile yerel değişken yaratıldı ise, en doğru davranış, bu değişekene gereksinme kalmayınca, Python çöp toplayıcısı beklenmeden del(değişken) şeklinde yaratılmış yerel değişkeni ortadan kaldırmaktır.

Ana fonksiyon olan main() fonksiyonu içinde çok kompakt bir kod bulunmaktadır. Bu kod, print() fonsiyonu içinde fonksiyonların birbirlerini çağırmaları ile oluşmuştur. İlk olarak, en iç fonksiyonu inceleyelim. appendList(defineList(),678) Bu ifade, appendList(x,y) fonksiyonun ilk argümanının, defineList() fonksiyonun döndürdüğü değer olduğunu belirtiyor, ikinci argüman olarak bir tamsayı literali olan 678 belirtilmiş. Bu şekilde, appendList() fonksiyonu çağrılmış oluyor ve döndürdüğü değer, updateList() fonksiyonuna argüman olarak kullanılıp, bu fonksiyonun döndürdüğü değer print() fonksiyonu ile görüntüleniyor. Bu kompakt kod, main() içinde, yerel değişken tanımına gerek bırakmamak için uygulanmıştır.

Programda, global alanda hiçbir global değişkenin tanımlanmamış olduğuna, sadece fonksiyon tanımları yapıldığına dikkat edilmelidir.

1.9.2 - Sabitler

Sabit değerler, global düzeyde tanımlanırlar ve gerek global düzeyde, gerekse fonksiyon alt düzeylerinde değerlerine erişilebilir. Sabit değerler, konvansiyon olarak, büyük harflerle tanıtılmış tanıtıcılara atanarak uygulanırlar. Örnek : PI = 3.1416 .

Python programlama dilinin genel bir incelenmesi ve program yapımı için gerekli temel bilgilerin verilmesi amacını taşıyan Bölüm 1 burada tamamlanmış olmaktadır. Bundan sonraki bölümde, Python programlarında kullanılan çeşitli genel yöntemleri inceleyeceğiz. Daha sonraki bölümlerde ise, veri tipleri üzerinde daha detaylı incelemeler yapacağız. En son olarak, çeşitli modülleri inceleyerek bu tanıtım çalışmamızı tamamlayacağız. İkinci Bölümün ilk konusu ile devam ediyoruz...