Bir modül Python kodumuzu mantıksal olarak organize etmenizi sağlar. İlgili kodu bir modüle gruplamak, kodun anlaşılmasını ve kullanılmasını kolaylaştırır. Bir modül, bağlayabileceğiniz ve başvuruda bulunabileceğiniz isteğe bağlı niteliklere sahip bir Python nesnesidir.
Basitçe, bir modül Python kodundan oluşan bir dosyadır. Bir modül fonksiyonları, sınıfları ve değişkenleri tanımlayabilir. Bir modül ayrıca çalıştırılabilir kod içerebilir.Öncelikle destek.py adında bir dosya oluşturup kaydedelim. (Notepad++ ile dosyayı oluşturabilirsiniz.)
|
1 2 3 |
def yaz( par ): print("Merhaba ", par) return |
9.1. import ifadesi
Başka bir Python dosyasında bir import deyimini yürüterek herhangi bir Python kaynak dosyasını bir modül olarak kullanabilirsiniz. Sözdizimi:
|
1 |
import modul1[, modul2[,... modulN] |
Bir yorumlayıcı import ifadesi ile karşılaştığında modül arama yolunda mevcutsa dosyanıza ekler. Arama yolu, yorumlayıcının modülleri yüklemeden önce arama yaptığı bir dizin listesidir. Örneğimizde destek.py bir klasör içine ekledik. Aynı klasöre diğer kodları ekleyeceğiz. Basit bir örnekle yaz fonksiyonuna ulaşalım.
|
1 2 |
import destek #destek.py dosyası koda eklendi. destek.yaz("Python!!!") #destek.py içindeki fonksiyon kullanıldı. |
|
1 |
Merhaba Python!!! |
Bir modül, import sayısına bakılmaksızın yalnızca bir kez yüklenir. Birden fazla import gerçekleşse bile modül yürütmesinin tekrar tekrar gerçekleşmesini engeller.
9.2. from … import ifadesi
Python’un deyimiyle, bir modülden belirli öznitelikleri geçerli ad alanına import etmemize izin verir. from … import sözdizimi:
|
1 |
from mod_adi import ad1[, ad2[, ... adN]] |
Örneğin,
|
1 |
from fib import fibonacci |
Bu ifade, tüm modül fib’ini mevcut isim alanına aktarmaz; sadece, fibonacci maddesini import edilen modülünün global sembol tablosuna ekler. Özellikle büyük bir modül dosyası ise ve tüm öznitelikler bellekte çok yer kaplayacağını için bu yapı kullanışlı bir çözüm olabilir. Başka bir deyişle, from … import yapısı sayesinde modülün sadece bir kısmını kullanabilirsiniz.
Aşağıdaki ifadeyi kullanarak bir modülden tüm öznitelikleri geçerli ad alanına aktarabilirsiniz. Örneğin,
|
1 |
from modname import * |
Ancak bu ifadeyi kullanırken dikkatli olmanızı öneririm. Sonuçta tüm modülü belleğe yüklüyorsunuz.
9.3. Yorumlayıcının modül araması
Modül eklendiğinde, yorumlayıcı aşağıdaki sıraya göre arama yapar:
- Geçerli dizin
- Modül bulunamazsa, Python daha sonra her dizini PYTHONPATH kabuk değişkeninde arar.
- Her şey başarısız olursa, Python varsayılan yolu denetler.
Modül arama yolu, sys.path değişkeni olarak sistem modülü sys’de saklanır. Sys.path değişkeni geçerli dizini, PYTHONPATH ve bağlı varsayılan yolu içerir.
9.4. Alan adları (Namespace) ve Kapsam Belirleme
Değişkenler, nesnelere eşlenen tanımlayıcılardır. Ad alanı, değişken adların (anahtarların) ve karşılık gelen nesnelerinin (değerleri) içeren bir sözlüktür. Bir Python ifadesi, yerel ad alanında ve global ad alanında değişkenlere erişebilir. Yerel ve genel değişken aynı ada sahipse, yerel değişken genel değişkeni gölgeler. Her fonksiyonun kendi yerel ad alanı vardır. Sınıf metotları, bir fonksiyonla aynı kapsam belirleme kuralını izler. Bir fonksiyonda bir değer atanmış herhangi bir değişkenin yerel olduğunu varsayar. Bu nedenle, bir fonksiyon içindeki bir global değişkene bir değer atamak için, önce genel ifadeyi kullanmalısınız. Bir örnek üzerinden görelim.
|
1 2 3 4 5 6 7 |
Para = 2000 def ParaEkle(): Para = Para + 1 print(Para) ParaEkle() print(Para) |
Bu kod aşağıdaki hata mesajını üretir.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
2000 --------------------------------------------------------------------------- UnboundLocalError Traceback (most recent call last) <ipython-input-1-964acae6ebb5> in <module>() 4 5 print(Para) ----> 6 ParaEkle() 7 print(Para) <ipython-input-1-964acae6ebb5> in ParaEkle() 1 Para = 2000 2 def ParaEkle(): ----> 3 Para = Para + 1 4 5 print(Para) UnboundLocalError: local variable 'Para' referenced before assignment |
Hatayı düzeltmek için,
|
3 |
global Para |
|
1 2 |
2000 2001 |
9.5. dir() fonksiyonu
Direkt Python içinde bulunan dir() fonksiyonu, bir modül tarafından tanımlanan adları içeren sıralanmış bir dizeler listesi döndürür. Liste, bir modülde tanımlanan tüm modüllerin, değişkenlerin ve fonksiyonların isimlerini içerir. Örneğin harici math kütüphanesi kodumuza import edelim ve bu modül içindeki modül, değişken ve fonksiyonlara ulaşalım.
|
1 2 3 4 |
import math #Python ile gelen matematik kütüphanesi icerik = dir(math) print(icerik) |
|
1 2 3 4 |
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc'] |
9.6. locals() ve globals() fonksiyonları
Globals () ve locals () fonksiyonları bulundukları yere göre global ve yerel ad alanlarına döndürmek için kullanılabilir. Bir fonksiyon içinde locals() çağrılırsa, bu fonksiyon yerel olarak erişilebilen tüm adları döndürür. Eğer bir fonksiyon içinde globals () çağrılırsa, bu fonksiyondan global olarak erişilebilen tüm isimleri geri gönderir. Her iki fonksiyonun dönüş tipi sözlüktür (dictionary). Bu nedenle, isimler keys () fonksiyonu kullanılarak elde edilebilir. (Daha fazla bilgi için dictionary konusuna bakın.)
9.7. reload() fonksiyonu
Modül bir koda import edildiğinde, bir modülün üst düzeyindeki kod sadece bir kez yürütülür. Eğer modülü yeniden yüklemek isterseniz, reload() fonksiyonunu kullanabilirsiniz. Kısacası, reload() fonksiyonu daha önceden yüklenen modülleri tekrar yüklemek için kullanılır. Sözdizimi:
|
1 |
reload(modul_ismi) |
9.8. Paketler
Bir paket, modüller ve alt paketler (hatta daha alt-alt paketleri) içeren tek bir Python uygulama ortamını tanımlayan bir hiyerarşik dosya dizin yapısıdır. Bu hiyerarşik yapıyı nasıl kullanacağımıza bir bakalım. Öncelikle Python kodunu yazacağımız klasör içine “dizin” adında bir klasör oluşturalım. Bu dizin içine üç adet dosya oluşturdum.
- dizin\dosya1.py
- dizin\dosya2.py
- dizin\dosya3.py
Üç dosyamıza çok basit fonksiyonlar yazalım. Örneğin,
|
1 2 3 |
def dosya1(): print("Merhaba ben dosya1") return |
Diğer iki dosyaya parametreli gönderim yaptım. Daha sonrasında, bu dizinin “__init__.py” isimli bir dosya içermesi gerekiyor. Bu dosya boş olabilir veya geçerli Python kodu içerebilir. Bu kod, bir paket alınacağı zaman çalıştırılacaktır, böylece bir paketin başlatılması için kullanılabilir, örn. diğer bazı modüllerin içe aktarıldığından veya bazı değerlerin ayarlandığından emin olmak için kullanılabilir. Şimdi bu dizine, modülümüzün alt modülleri olacak tüm Python dosyalarını yerleştirebiliriz.
- dizin\__init__.py
Şimdi ana klasörümüze oluşturduğumuz bir “.py” dosyasından bu dizine ulaşalım ve dizin içindeki modüller (dosyalar) içindeki fonksiyonları kullanalım.
|
1 2 3 4 5 6 7 8 |
import dizin #dizin klasöründe __init__ dosyasını yükler dizin #hangi klasörün arama yoluna eklendiğine bakmak için kullanılabilir. from dizin import dosya1 dosya1.dosya1() from dizin import dosya3 from dizin import dosya2 dosya3.dosya3("Deneme") dosya2.dosya2("Test") |
|
1 2 3 |
Merhaba ben dosya1 Merhaba Deneme Merhaba Test |