6. Modüller
***********

Python yorumlayıcısından çıkıp tekrar girerseniz, yaptığınız tanımlar
(fonksiyonlar  ve değişkenler) kaybolur. Bu nedenle, daha uzun bir
program yazmak istiyorsanız, girdiyi yorumlayıcıya hazırlarken bir
metin düzenleyicisi kullanmak ve o dosyayla girdi olarak çalıştırmak
daha iyidir.  Bu bir *script* oluşturma olarak bilinir.  Programınız
uzadıkça, daha kolay bakım için birkaç dosyaya bölmek
isteyebilirsiniz.  Ayrıca, tanımını her programa kopyalamadan, birkaç
programda yazdığınız kullanışlı bir fonksiyonu kullanmak
isteyebilirsiniz.

Bunu desteklemek için Python, tanımları bir dosyaya koymanın ve
bunları bir komut dosyasında veya yorumlayıcının etkileşimli bir
örneğinde kullanmanın bir yolunu sağlar. Böyle bir dosyaya *module*
denir; bir modülden alınan tanımlar diğer modüllere veya *main*
modülüne (en üst düzeyde ve hesap makinesi modunda yürütülen bir komut
dosyasında erişiminiz olan değişkenlerin derlenmesi) aktarılabilir.

Modül, Python tanımlarını ve ifadelerini içeren bir dosyadır.  Dosya
adı, ".py" son ekini içeren modül adıdır.  Bir modül içinde, modülün
adı (dize olarak) "__name__" genel değişkeninin değeri olarak
kullanılabilir.  Örneğin, geçerli dizinde aşağıdaki içeriklerle
"fibo.py" adlı bir dosya oluşturmak için en sevdiğiniz metin
düzenleyicisini kullanın:

   # Fibonacci numbers module

   def fib(n):    # write Fibonacci series up to n
       a, b = 0, 1
       while a < n:
           print(a, end=' ')
           a, b = b, a+b
       print()

   def fib2(n):   # return Fibonacci series up to n
       result = []
       a, b = 0, 1
       while a < n:
           result.append(a)
           a, b = b, a+b
       return result

Şimdi Python yorumlayıcısına girin ve bu modülü aşağıdaki komutla içe
aktarın:

   >>> import fibo

Bu, "fibo" 'da tanımlanan işlevlerin adlarını doğrudan geçerli
*namespace* 'e  eklemez (daha fazla ayrıntı için bkz. Python Etki
Alanları ve Ad Alanları); oraya sadece "fibo" modül adını ekler. Modül
adını kullanarak şu işlevlere erişebilirsiniz:

   >>> fibo.fib(1000)
   0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
   >>> fibo.fib2(100)
   [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
   >>> fibo.__name__
   'fibo'

Bir işlevi sık sık kullanmayı düşünüyorsanız, işlevi yerel bir ada
atayabilirsiniz:

   >>> fib = fibo.fib
   >>> fib(500)
   0 1 1 2 3 5 8 13 21 34 55 89 144 233 377


6.1. Modüller hakkında daha fazla
=================================

Bir modül, işlev tanımlarının yanı sıra çalıştırılabilir ifadeler de
içerebilir. Bu ifadeler modülü başlatmayı amaçlamaktadır. Yalnızca bir
import ifadesinde modül adıyla karşılaşıldığında *ilk* kez
yürütülürler. [1] (Dosya komut dosyası olarak yürütülürse de
çalıştırılırlar.)

Her modülün, modülde tanımlanan tüm işlevler tarafından genel ad alanı
olarak kullanılan kendi özel ad alanı vardır. Böylece, bir modülün
yazarı, bir kullanıcının genel değişkenleriyle yanlışlıkla çakışma
endişesi duymadan, modüldeki genel değişkenleri kullanabilir. Öte
yandan, ne yaptığınızı biliyorsanız, bir modülün global
değişkenlerine, işlevlerine atıfta bulunmak için kullanılan
"modname.itemname" notasyonuyla dokunabilirsiniz.

Modüller diğer modülleri içe aktarabilir. Tüm "import" ifadelerinin
bir modülün (veya bu konuda betiğin) başına yerleştirilmesi alışılmış
bir durumdur ancak gerekli değildir. İçe aktarılan modül adları, bir
modülün en üst düzeyine yerleştirilirse (herhangi bir işlev veya
sınıfın dışında), modülün genel ad alanına eklenir.

"import" ifadesinin, bir modülden adları doğrudan içe aktaran modülün
ad alanına aktaran bir çeşidi vardır. Örneğin:

   >>> from fibo import fib, fib2
   >>> fib(500)
   0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Bu, içe aktarmaların yerel ad alanında alındığı modül adını
tanıtmaz(bu nedenle örnekte "fibo" tanımlanmamıştır).

Bir modülün tanımladığı tüm adları içe aktarmak için bir varyant bile
vardır:

   >>> from fibo import *
   >>> fib(500)
   0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Bu, alt çizgiyle başlayanlar ("_") dışındaki tüm isimleri alır. Çoğu
durumda Python programcıları bu özelliği kullanmaz, çünkü
yorumlayıcıya bilinmeyen bir ad kümesi ekler ve muhtemelen önceden
tanımladığınız bazı şeyleri gizler.

Genel olarak, bir modülden veya paketten "*" içeri aktarma
uygulamasının, genellikle okunamayan koda neden olduğundan hoş
karşılanmadığına dikkat edin. Ancak, etkileşimli oturumlarda yazmayı
kaydetmek için kullanmak sorun değildir.

Modül adının ardından "as" geliyorsa, "as" 'den sonraki ad doğrudan
içe aktarılan modüle bağlanır.

   >>> import fibo as fib
   >>> fib.fib(500)
   0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Bu, modülün "import fibo" 'nun yapacağı şekilde etkin bir şekilde içe
aktarılmasıdır, tek farkı "fib" olarak mevcut olmasıdır.

Benzer efektlere sahip "from" kullanılırken de kullanılabilir:

   >>> from fibo import fib as fibonacci
   >>> fibonacci(500)
   0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Not:

  Verimlilik nedeniyle, her modül yorumlayıcı oturumu başına yalnızca
  bir kez içe aktarılır.  Bu nedenle, modüllerinizi değiştirirseniz,
  yorumlayıcıyı yeniden başlatmanız gerekir - veya etkileşimli olarak
  test etmek istediğiniz tek bir modülse, "importlib.reload()",
  örneğin "importlib; importlib.reload(modulename)".


6.1.1. Modülleri komut dosyası olarak yürütme
---------------------------------------------

Bir Python modülünü :: ile çalıştırdığınızda:

   python fibo.py <arguments>

modüldeki kod, içe aktardığınız gibi yürütülür, ancak "__name__"
""__main__"" olarak ayarlanır. Bu, modülünüzün sonuna bu kodu
ekleyerek:

   if __name__ == "__main__":
       import sys
       fib(int(sys.argv[1]))

dosyayı bir komut dosyası ve içe aktarılabilir bir modül olarak
kullanılabilir hale getirebilirsiniz, çünkü komut satırını ayrıştıran
kod yalnızca modül "main" dosya olarak yürütülürse çalışır:

   $ python fibo.py 50
   0 1 1 2 3 5 8 13 21 34

Modül içe aktarılırsa kod çalıştırılmaz:

   >>> import fibo
   >>>

Bu genellikle bir modüle uygun bir kullanıcı arabirimi sağlamak veya
test amacıyla kullanılır (modülü komut dosyası olarak çalıştırmak bir
test paketi yürütür).


6.1.2. Modül Arama Yolu
-----------------------

When a module named "spam" is imported, the interpreter first searches
for a built-in module with that name. These module names are listed in
"sys.builtin_module_names". If not found, it then searches for a file
named "spam.py" in a list of directories given by the variable
"sys.path".  "sys.path" is initialized from these locations:

* Girdi komut dosyasını içeren dizin (veya dosya belirtilmediğinde
  geçerli dizin).

* "PYTHONPATH" (kabuk değişkeni "PATH" ile aynı sözdizimine sahip
  dizin adlarının listesi).

* Kuruluma bağlı varsayılan (kural olarak, "site" modülü tarafından
  işlenen bir "site-packages" dizini dahil).

Daha fazla ayrıntı The initialization of the sys.path module search
path adresindedir.

Not:

  Symlink'leri destekleyen dosya sistemlerinde, symlink izlendikten
  sonra girdi komut dosyasını içeren dizin hesaplanır. Başka bir
  deyişle, symlink içeren dizin modül arama yoluna **not** eklenir.

Başlatıldıktan sonra Python programları "sys.path" değiştirebilir.
Çalıştırılmakta olan komut dosyasını içeren dizin, arama yolunun
başına, standart kitaplık yolunun önüne yerleştirilir. Bu, kitaplık
dizininde aynı ada sahip modüller yerine bu dizindeki komut
dosyalarının yüklanacağı anlamına gelir. Değiştirme amaçlanmadığı
sürece bu bir hatadır.  Daha fazla bilgi için Standart modüller
bölümüne bakın.


6.1.3. "Derlenmiş" Python dosyaları
-----------------------------------

Modüllerin yüklenmesini hızlandırmak için Python, her modülün
derlenmiş sürümünü "__pycache__" dizininde "module.*version*.pyc" adı
altında önbelleğe alır; burada sürüm, derlenen dosyanın biçimini
kodlar; genellikle Python sürüm numarasını içerir. Örneğin, CPython
3.3 sürümünde spam.py'nin derlenmiş sürümü
"__pycache__/spam.cpython-33.pyc" olarak önbelleğe alınacaktır. Bu
adlandırma kuralı, farklı sürümlerden ve Python'un farklı
sürümlerinden derlenmiş modüllerin bir arada var olmasına izin verir.

Python, eski olup olmadığını ve yeniden derlenmesi gerekip
gerekmediğini görmek için kaynağın değişiklik tarihini derlenmiş
sürümle karşılaştırır. Bu tamamen otomatik bir işlemdir. Ayrıca,
derlenen modüller platformdan bağımsızdır, bu nedenle aynı kitaplık
farklı mimarilere sahip sistemler arasında paylaşılabilir.

Python iki durumda önbelleği kontrol etmez. İlk olarak, doğrudan komut
satırından yüklenen modülün sonucunu her zaman yeniden derler ve
saklamaz. İkincisi, kaynak modül yoksa önbelleği kontrol etmez. Kaynak
olmayan (yalnızca derlenmiş) bir dağıtımı desteklemek için, derlenen
modül kaynak dizinde olmalı ve bir kaynak modül olmamalıdır.

Uzmanlar için bazı ipuçları:

* Derlenmiş bir modülün boyutunu küçültmek için Python komutundaki
  "-O" veya "-OO" anahtarlarını kullanabilirsiniz. "-O" anahtarı,
  onaylama ifadelerini kaldırır, "-OO" anahtarı, hem assert
  ifadelerini hem de __doc__ dizelerini kaldırır. Bazı programlar
  bunların kullanılabilir olmasına güvenebileceğinden, bu seçeneği
  yalnızca ne yaptığınızı biliyorsanız kullanmalısınız. "Optimize
  edilmiş" modüller bir "opt-" etiketine sahiptir ve genellikle daha
  küçüktür. Gelecekteki sürümler, optimizasyonun etkilerini
  değiştirebilir.

* Bir program ".pyc" dosyasından okunduğunda, ".py" dosyasından
  okunduğundan daha hızlı çalışmaz; ".pyc" dosyaları hakkında daha
  hızlı olan tek şey, yüklenme hızlarıdır.

* "compileall" modülü, bir dizindeki tüm modüller için .pyc dosyaları
  oluşturabilir.

* **PEP 3147** 'de, kararların bir akış şeması da dahil olmak üzere,
  bu süreç hakkında daha fazla ayrıntı bulunmaktadır.


6.2. Standart modüller
======================

Python, ayrı bir belge olan Python Kütüphanesi Referansında (bundan
sonra "Kütüphane Referansı") açıklanan standart modüllerden oluşan bir
kütüphane ile birlikte gelir. Bazı modüller yorumlayıcıya
yerleştirilmiştir; bunlar, dilin çekirdeğinin bir parçası olmayan,
ancak yine de verimlilik için veya sistem çağrıları gibi işletim
sistemi ilkellerine erişim sağlamak için yerleşik olan işlemlere
erişim sağlar. Bu tür modüller seti, aynı zamanda temel platforma da
bağlı olan bir yapılandırma seçeneğidir. Örneğin, "winreg" modülü
yalnızca Windows sistemlerinde sağlanır. Belirli bir modül biraz
ilgiyi hak ediyor: Her Python yorumlayıcısında yerleşik olan "sys".
"sys.ps1" ve "sys.ps2" değişkenleri, birincil ve ikincil bilgi
istemleri olarak kullanılan dizeleri tanımlar:

   >>> import sys
   >>> sys.ps1
   '>>> '
   >>> sys.ps2
   '... '
   >>> sys.ps1 = 'C> '
   C> print('Yuck!')
   Yuck!
   C>

Bu iki değişken yalnızca yorumlayıcı etkileşimli moddaysa tanımlanır.

"sys.path" değişkeni, yorumlayıcının modüller için arama yolunu
belirleyen bir dizeler listesidir. "PYTHONPATH" ortam değişkeninden
veya "PYTHONPATH" ayarlanmamışsa yerleşik bir varsayılan değerden
alınan varsayılan bir yola başlatılır. Standart liste işlemlerini
kullanarak değiştirebilirsiniz:

   >>> import sys
   >>> sys.path.append('/ufs/guido/lib/python')


6.3. "dir()" Fonksiyonu
=======================

Yerleşik fonksiyon "dir()", bir modülün hangi adları tanımladığını
bulmak için kullanılır. Sıralanmış bir dize listesi döndürür:

   >>> import fibo, sys
   >>> dir(fibo)
   ['__name__', 'fib', 'fib2']
   >>> dir(sys)  
   ['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__',
    '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__',
    '__stderr__', '__stdin__', '__stdout__', '__unraisablehook__',
    '_clear_type_cache', '_current_frames', '_debugmallocstats', '_framework',
    '_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook',
    'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix',
    'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing',
    'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info',
    'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info',
    'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_origin_tracking_depth',
    'getallocatedblocks', 'getdefaultencoding', 'getdlopenflags',
    'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile',
    'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval',
    'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
    'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value',
    'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks',
    'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'pycache_prefix',
    'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', 'setdlopenflags',
    'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr',
    'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', 'version_info',
    'warnoptions']

Argümanlar olmadan, "dir()", şu anda tanımladığınız adları listeler:

   >>> a = [1, 2, 3, 4, 5]
   >>> import fibo
   >>> fib = fibo.fib
   >>> dir()
   ['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']

Her tür adın listelendiğini unutmayın: değişkenler, modüller,
fonksiyonlar vb.

"dir()" yerleşik fonksiyonlarun ve değişkenlerin adlarını listelemez.
Bunların bir listesini istiyorsanız, standart modül "builtins" 'de
tanımlanırlar:

   >>> import builtins
   >>> dir(builtins)  
   ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',
    'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning',
    'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',
    'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning',
    'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',
    'FileExistsError', 'FileNotFoundError', 'FloatingPointError',
    'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',
    'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError',
    'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError',
    'MemoryError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented',
    'NotImplementedError', 'OSError', 'OverflowError',
    'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError',
    'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning',
    'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',
    'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError',
    'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',
    'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning',
    'ValueError', 'Warning', 'ZeroDivisionError', '_', '__build_class__',
    '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs',
    'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable',
    'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits',
    'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit',
    'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr',
    'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass',
    'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview',
    'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property',
    'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice',
    'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars',
    'zip']


6.4. Paketler
=============

Packages are a way of structuring Python's module namespace by using
"dotted module names".  For example, the module name "A.B" designates
a submodule named "B" in a package named "A".  Just like the use of
modules saves the authors of different modules from having to worry
about each other's global variable names, the use of dotted module
names saves the authors of multi-module packages like NumPy or Pillow
from having to worry about each other's module names.

Ses dosyalarının ve ses verilerinin tek tip işlenmesi için bir modül
koleksiyonu ("paket") tasarlamak istediğinizi varsayalım. Birçok
farklı ses dosyası biçimi vardır (genellikle uzantılarıyla tanınır,
örneğin: ".wav", ".aiff", ".au") bu nedenle, çeşitli dosya biçimleri
arasında dönüşüm için büyüyen bir modül koleksiyonu oluşturmanız ve
sürdürmeniz gerekebilir. Ses verileri üzerinde gerçekleştirmek
isteyebileceğiniz birçok farklı işlem de vardır (karıştırma, eko
ekleme, ekolayzır işlevi uygulama, yapay bir stereo efekti oluşturma
gibi) bu nedenle ek olarak, bu işlemleri gerçekleştirmek için hiç
bitmeyen bir modül akışı yazıyor olacaksınız. İşte paketiniz için
olası bir yapı (hiyerarşik bir dosya sistemi cinsinden ifade edilir):

   sound/                          Top-level package
         __init__.py               Initialize the sound package
         formats/                  Subpackage for file format conversions
                 __init__.py
                 wavread.py
                 wavwrite.py
                 aiffread.py
                 aiffwrite.py
                 auread.py
                 auwrite.py
                 ...
         effects/                  Subpackage for sound effects
                 __init__.py
                 echo.py
                 surround.py
                 reverse.py
                 ...
         filters/                  Subpackage for filters
                 __init__.py
                 equalizer.py
                 vocoder.py
                 karaoke.py
                 ...

Paketi içe aktarırken Python, paket alt dizinini arayan "sys.path"
üzerindeki dizinleri arar.

The "__init__.py" files are required to make Python treat directories
containing the file as packages (unless using a *namespace package*, a
relatively advanced feature). This prevents directories with a common
name, such as "string", from unintentionally hiding valid modules that
occur later on the module search path. In the simplest case,
"__init__.py" can just be an empty file, but it can also execute
initialization code for the package or set the "__all__" variable,
described later.

Paketin kullanıcıları, paketin içindeki ayrı modülleri içe
aktarabilir, örneğin:

   import sound.effects.echo

This loads the submodule "sound.effects.echo".  It must be referenced
with its full name.

   sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

Alt modülü içe aktarmanın alternatif bir yolu:

   from sound.effects import echo

This also loads the submodule "echo", and makes it available without
its package prefix, so it can be used as follows:

   echo.echofilter(input, output, delay=0.7, atten=4)

Yine başka bir varyasyon, istenen işlevi veya değişkeni doğrudan içe
aktarmaktır:

   from sound.effects.echo import echofilter

Again, this loads the submodule "echo", but this makes its function
"echofilter()" directly available:

   echofilter(input, output, delay=0.7, atten=4)

"from package import item" kullanırken, öğenin paketin bir alt modülü
(veya alt paketi) veya pakette tanımlanmış bir fonksiyon, sınıf veya
değişken gibi başka bir ad olabileceğini unutmayın. "import" ifadesi
önce öğenin pakette tanımlanıp tanımlanmadığını test eder; değilse
modül olduğunu varsayar ve yüklemeye çalışır. Onu bulamazsa, bir
"ImportError" istisnası ortaya çıkar.

Aksine, "import item.subitem.subsubitem" gibi bir sözdizimi
kullanırken, sonuncusu hariç her öğe bir paket olmalıdır; son öğe bir
modül veya paket olabilir, ancak önceki öğede tanımlanan bir sınıf,
fonksiyon veya değişken olamaz.


6.4.1. Bir Paketten * İçe Aktarma
---------------------------------

Şimdi, kullanıcı "from sound.effects import *" yazdığında ne olur?
İdeal olarak, bunun bir şekilde dosya sistemine gitmesi, pakette hangi
alt modüllerin bulunduğunu bulması ve hepsini içe aktarması umulur. Bu
uzun zaman alabilir ve alt modüllerin içe aktarılması, yalnızca alt
modül açıkça içe aktarıldığında gerçekleşmesi gereken istenmeyen yan
etkilere neden olabilir.

Tek çözüm, paket yazarının paketin açık bir dizinini sağlamasıdır.
"import" ifadesi aşağıdaki kuralı kullanır: eğer bir paketin
"__init__.py" kodu "__all__" adlı bir liste tanımlarsa, "from package
import *" ile karşılaşıldığında alınması gereken modül adlarının
listesi olarak alınır. Paketin yeni bir sürümü yayınlandığında bu
listeyi güncel tutmak paket yazarının sorumluluğundadır. Paket
yazarları, paketlerinden * içe aktarmak için bir kullanım görmezlerse,
onu desteklememeye de karar verebilirler. Örneğin,
"sound/effects/__init__.py" dosyası şu kodu içerebilir:

   __all__ = ["echo", "surround", "reverse"]

This would mean that "from sound.effects import *" would import the
three named submodules of the "sound.effects" package.

Be aware that submodules might become shadowed by locally defined
names. For example, if you added a "reverse" function to the
"sound/effects/__init__.py" file, the "from sound.effects import *"
would only import the two submodules "echo" and "surround", but *not*
the "reverse" submodule, because it is shadowed by the locally defined
"reverse" function:

   __all__ = [
       "echo",      # refers to the 'echo.py' file
       "surround",  # refers to the 'surround.py' file
       "reverse",   # !!! refers to the 'reverse' function now !!!
   ]

   def reverse(msg: str):  # <-- this name shadows the 'reverse.py' submodule
       return msg[::-1]    #     in the case of a 'from sound.effects import *'

If "__all__" is not defined, the statement "from sound.effects import
*" does *not* import all submodules from the package "sound.effects"
into the current namespace; it only ensures that the package
"sound.effects" has been imported (possibly running any initialization
code in "__init__.py") and then imports whatever names are defined in
the package.  This includes any names defined (and submodules
explicitly loaded) by "__init__.py".  It also includes any submodules
of the package that were explicitly loaded by previous "import"
statements.  Consider this code:

   import sound.effects.echo
   import sound.effects.surround
   from sound.effects import *

In this example, the "echo" and "surround" modules are imported in the
current namespace because they are defined in the "sound.effects"
package when the "from...import" statement is executed.  (This also
works when "__all__" is defined.)

Bazı modüller, "import *" kullandığınızda yalnızca belirli kalıpları
takip eden adları dışa aktarmak üzere tasarlanmış olsa da, üretim
kodunda yine de kötü uygulama olarak kabul edilir.

Unutmayın, "from package import specific_submodule" kullanmanın yanlış
bir tarafı yok! Aslında, içe aktarma modülünün farklı paketlerden aynı
ada sahip alt modülleri kullanması gerekmedikçe, önerilen gösterim
budur.


6.4.2. Paket İçi Referanslar
----------------------------

When packages are structured into subpackages (as with the "sound"
package in the example), you can use absolute imports to refer to
submodules of siblings packages.  For example, if the module
"sound.filters.vocoder" needs to use the "echo" module in the
"sound.effects" package, it can use "from sound.effects import echo".

You can also write relative imports, with the "from module import
name" form of import statement.  These imports use leading dots to
indicate the current and parent packages involved in the relative
import.  From the "surround" module for example, you might use:

   from . import echo
   from .. import formats
   from ..filters import equalizer

Göreceli içe aktarmaların geçerli modülün adını temel aldığını
unutmayın. Ana modülün adı her zaman ""__main__"" olduğundan, Python
uygulamasının ana modülü olarak kullanılması amaçlanan modüller her
zaman mutlak içe aktarma kullanmalıdır.


6.4.3. Birden Çok Dizindeki Paketler
------------------------------------

Paketler bir özel özelliği daha destekler, "__path__". Bu, o dosyadaki
kod yürütülmeden önce paketin "__init__.py" dosyasını tutan dizinin
adını içeren bir liste olacak şekilde başlatılır. Bu değişken
değiştirilebilir; bunu yapmak, pakette bulunan modüller ve alt
paketler için gelecekteki aramaları etkiler.

Bu özelliğe sıklıkla ihtiyaç duyulmasa da, bir pakette bulunan modül
dizisini genişletmek için kullanılabilir.

-[ Dipnotlar ]-

[1] Aslında işlev tanımları aynı zamanda 'çalıştırılan' 'ifadelerdir';
    modül düzeyinde bir işlev tanımının çalıştırılması, işlev adını
    modülün genel ad alanına ekler.
