6. Modul-Modul
**************

Jika Anda berhenti dari *interpreter* Python dan memasukkannya lagi,
definisi yang Anda buat (fungsi dan variabel) akan hilang. Karena itu,
jika Anda ingin menulis program yang agak lebih panjang, Anda lebih
baik menggunakan editor teks untuk menyiapkan input bagi penerjemah
dan menjalankannya dengan file itu sebagai input. Ini dikenal sebagai
membuat *script*. Saat program Anda menjadi lebih panjang, Anda
mungkin ingin membaginya menjadi beberapa file untuk pengelolaan yang
lebih mudah. Anda mungkin juga ingin menggunakan fungsi praktis yang
Anda tulis di beberapa program tanpa menyalin definisi ke setiap
program.

Untuk mendukung ini, Python memiliki cara untuk meletakkan definisi
dalam file dan menggunakannya dalam skrip atau dalam contoh interaktif
dari *interpreter*. File seperti itu disebut *module*; definisi dari
modul dapat *imported* ke modul lain atau ke modul *main* (kumpulan
variabel yang Anda memiliki akses ke dalam skrip yang dieksekusi di
tingkat atas dan dalam mode kalkulator).

Modul adalah file yang berisi definisi dan pernyataan Python. Nama
berkas adalah nama modul dengan akhiran ".py" diakhirnya. Dalam sebuah
modul, nama modul (sebagai string) tersedia sebagai nilai variabel
global "__name__". Misalnya, gunakan editor teks favorit Anda untuk
membuat bernama bernama "fibo.py" di direktori saat ini dengan konten
berikut

   # 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

Sekarang masukkan interpreter Python dan impor modul ini dengan
perintah berikut:

   >>> import fibo

This does not add the names of the functions defined in "fibo"
directly to the current *namespace* (see Lingkup Python dan Namespaces
for more details); it only adds the module name "fibo" there. Using
the module name you can access the functions:

   >>> 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'

Jika Anda sering ingin menggunakan suatu fungsi, Anda dapat
menetapkannya ke nama lokal:

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


6.1. Lebih lanjut tentang Modul
===============================

Modul dapat berisi pernyataan yang dapat dieksekusi serta definisi
fungsi. Pernyataan ini dimaksudkan untuk menginisialisasi modul.
Mereka dieksekusi hanya *first* kali nama modul ditemui dalam
pernyataan impor. [1] (Mereka juga dijalankan jika file dieksekusi
sebagai skrip.)

Each module has its own private namespace, which is used as the global
namespace by all functions defined in the module. Thus, the author of
a module can use global variables in the module without worrying about
accidental clashes with a user's global variables. On the other hand,
if you know what you are doing you can touch a module's global
variables with the same notation used to refer to its functions,
"modname.itemname".

Modules can import other modules.  It is customary but not required to
place all "import" statements at the beginning of a module (or script,
for that matter).  The imported module names, if placed at the top
level of a module (outside any functions or classes), are added to the
module's global namespace.

There is a variant of the "import" statement that imports names from a
module directly into the importing module's namespace.  For example:

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

This does not introduce the module name from which the imports are
taken in the local namespace (so in the example, "fibo" is not
defined).

Bahkan ada varian untuk mengimpor semua nama yang didefinisikan oleh
modul:

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

Ini mengimpor semua nama kecuali yang dimulai dengan garis bawah
("_"). Dalam kebanyakan kasus, programmer Python tidak menggunakan
fasilitas ini karena ia memperkenalkan sekumpulan nama yang tidak
diketahui ke dalam *interpreter*, mungkin menyembunyikan beberapa hal
yang sudah Anda definisikan.

Perhatikan bahwa secara umum praktik mengimpor "*" dari modul atau
paket tidak disukai, karena sering menyebabkan kode yang kurang dapat
dibaca. Namun, boleh saja menggunakannya untuk menghemat pengetikan di
sesi interaktif.

Jika nama modul diikuti oleh "as", maka nama setelah "as" terikat
langsung ke modul yang diimpor.

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

Ini secara efektif mengimpor modul dengan cara yang sama dengan
"import fibo" akan dilakukan, dengan satu-satunya perbedaan adalah
sebagai "fib".

Itu juga dapat digunakan ketika menggunakan "from" dengan efek yang
sama:

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

Catatan:

  Untuk alasan efisiensi, setiap modul hanya diimpor satu kali per
  sesi *interpreter*. Karenanya, jika Anda mengubah modul, Anda harus
  memulai ulang *interpreter* -- atau, jika hanya satu modul yang
  ingin Anda uji secara interaktif, gunakan "importlib.reload()", mis.
  "import importlib; importlib.reload(modulename)".


6.1.1. Mengoperasikan modul sebagai skrip
-----------------------------------------

Ketika Anda mengoperasikan modul Python dengan

   python fibo.py <arguments>

kode dalam modul akan dieksekusi, sama seperti jika Anda mengimpornya,
tetapi dengan "__name__" diatur ke ""__main__"". Itu berarti bahwa
dengan menambahkan kode ini di akhir modul Anda

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

Anda dapat membuat berkas dapat digunakan sebagai skrip dan juga modul
yang dapat diimpor, karena kode yang mengurai *parsing* baris perintah
hanya beroperasi jika modul dieksekusi sebagai berkas "main":

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

Jika modul diimpor, kode ini tidak dioperasikan

   >>> import fibo
   >>>

Ini sering digunakan baik untuk menyediakan antarmuka pengguna yang
nyaman ke modul, atau untuk tujuan pengujian (menjalankan modul
sebagai skrip mengeksekusi rangkaian pengujian).


6.1.2. Jalur Pencarian Modul
----------------------------

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:

* Direktori yang berisi skrip masukan (atau direktori saat ini ketika
  tidak ada file ditentukan).

* "PYTHONPATH" (daftar nama direktori, dengan sintaksis yang sama
  dengan variabel shell "PATH").

* The installation-dependent default (by convention including a "site-
  packages" directory, handled by the "site" module).

More details are at The initialization of the sys.path module search
path.

Catatan:

  Pada sistem file yang mendukung symlink, direktori yang berisi skrip
  masukan dihitung setelah symlink diikuti. Dengan kata lain direktori
  yang berisi symlink **not** ditambahkan ke jalur pencarian modul.

Setelah inisialisasi, program Python dapat memodifikasi: data
:*sys.path*. Direktori yang berisi skrip yang dijalankan ditempatkan
di awal jalur pencarian, di depan jalur pustaka standar. Ini berarti
bahwa skrip dalam direktori itu akan dimuat bukan modul dengan nama
yang sama di direktori pustaka. Ini adalah kesalahan kecuali
penggantian memang diharapkan. Lihat bagian Modul Standar untuk
informasi lebih lanjut.


6.1.3. Berkas Python "Compiled"
-------------------------------

Untuk mempercepat memuat modul, Python menyimpan *cache* versi
terkompilasi dari setiap modul di direktori "__pycache__" dengan nama
"module. *version*.pyc", di mana versi menyandikan format berkas
terkompilasi; umumnya berisi nomor versi Python. Misalnya, dalam rilis
CPython 3.3 versi yang dikompilasi dari spam.py akan di-*cache*
sebagai "__pycache__/spam.cpython-33.pyc". Konvensi penamaan ini
memungkinkan modul yang dikompilasi dari rilis yang beragam dan versi
Python yang berbeda untuk hidup berdampingan.

Python memeriksa tanggal modifikasi sumber terhadap versi yang
dikompilasi untuk melihat apakah itu kedaluwarsa dan perlu dikompilasi
ulang. Ini adalah proses yang sepenuhnya otomatis. Juga, modul yang
dikompilasi adalah platform-independen, sehingga perpustakaan yang
sama dapat dibagi di antara sistem dengan arsitektur yang berbeda.

Python tidak memeriksa *cache* dalam dua keadaan. Pertama, selalu
mengkompilasi ulang dan tidak menyimpan hasil untuk modul yang dimuat
langsung dari baris perintah. Kedua, itu tidak memeriksa *cache* jika
tidak ada modul sumber. Untuk mendukung distribusi non-sumber
(dikompilasi saja), modul yang dikompilasi harus ada di direktori
sumber, dan tidak boleh ada modul sumber.

Beberapa tips untuk para ahli:

* Anda dapat menggunakan "-O" atau "-OO" mengaktifkan perintah Python
  untuk mengurangi ukuran modul yang dikompilasi. Saklar "-O"
  menghapus pernyataan tegas *assert*, saklar "-OO" menghapus
  pernyataan tegas *assert* dan string __doc__. Karena beberapa
  program bergantung pada ketersediaannya, Anda hanya boleh
  menggunakan opsi ini jika Anda tahu apa yang Anda lakukan. Modul
  "Optimized" memiliki tag "opt-" dan biasanya lebih kecil. Rilis di
  masa depan dapat mengubah efek pengoptimalan.

* Suatu program tidak berjalan lebih cepat ketika itu dibaca dari file
  ".pyc" daripada ketika itu dibaca dari file ".py"; satu-satunya hal
  yang lebih cepat tentang berkas ".pyc" adalah kecepatan memuatnya.

* Modul "compileall" dapat membuat berkas .pyc untuk semua modul dalam
  direktori.

* Ada detail lebih lanjut tentang proses ini, termasuk bagan alur
  keputusan, di **PEP 3147**.


6.2. Modul Standar
==================

Python dilengkapi dengan pustaka modul standar, yang dijelaskan dalam
dokumen terpisah, Referensi Pustaka Python ("Library Reference"
selanjutnya). Beberapa modul dibangun ke dalam interpreter; ini
menyediakan akses ke operasi yang bukan bagian dari inti bahasa tetapi
tetap dibangun, baik untuk efisiensi atau untuk menyediakan akses ke
sistem operasi primitif seperti pemanggilan sistem. Himpunan modul
tersebut adalah opsi konfigurasi yang juga tergantung pada platform
yang mendasarinya. Sebagai contoh, modul "winreg" hanya disediakan
pada sistem Windows. Satu modul tertentu patut mendapat perhatian:
"sys", yang dibangun ke dalam setiap interpreter Python. Variabel
"sys.ps1" dan "sys.ps2" menentukan string yang digunakan sebagai
prompt primer dan sekunder

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

Kedua variabel ini hanya ditentukan jika interpreter dalam mode
interaktif.

Variabel "sys.path" adalah daftar string yang menentukan jalur
pencarian *interpreter* untuk modul. Ini diinisialisasi ke jalur
default yang diambil dari variabel lingkungan "PYTHONPATH", atau dari
bawaan bawaan jika "PYTHONPATH" tidak disetel. Anda dapat
memodifikasinya menggunakan operasi standar untuk *list*:

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


6.3. Fungsi "dir()"
===================

Fungsi bawaan "dir()" digunakan untuk mencari tahu nama-nama yang
ditentukan oleh modul. Ia mengembalikan *list* string yang diurutkan:

   >>> 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']

Tanpa argumen, "dir()" mencantumkan nama yang telah Anda tentukan saat
ini:

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

Perhatikan bahwa ini mencantumkan semua jenis nama: variabel, modul,
fungsi, dll.

"dir()" tidak mencantumkan nama fungsi dan variabel bawaan. Jika Anda
ingin daftar itu, mereka didefinisikan dalam modul standar "builtins":

   >>> 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. Paket
==========

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.

Misalkan Anda ingin merancang koleksi modul ("paket") untuk penanganan
berkas suara dan data suara yang seragam. Ada banyak format berkas
suara yang berbeda (biasanya dikenali oleh ekstensi mereka, misalnya:
".wav", ".aiff", ".au"), jadi Anda mungkin perlu membuat dan
memelihara koleksi modul yang terus bertambah untuk konversi antara
berbagai format file. Ada juga banyak operasi berbeda yang mungkin
ingin Anda lakukan pada data suara (seperti mencampur, menambahkan
gema, menerapkan fungsi equalizer, menciptakan efek stereo buatan),
jadi selain itu Anda akan menulis aliran modul tanpa henti untuk
melakukan operasi ini. Berikut adalah struktur yang mungkin untuk
paket Anda (dinyatakan dalam hierarki sistem file):

   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
                 ...

Saat mengimpor paket, Python mencari melalui direktori pada "sys.path"
mencari subdirektori paket.

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.

Pengguna paket dapat mengimpor modul individual dari paket, misalnya:

   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)

Cara alternatif mengimpor submodule adalah:

   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)

Namun variasi lain adalah mengimpor fungsi atau variabel yang
diinginkan secara langsung:

   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)

Perhatikan bahwa ketika menggunakan "from package import item", item
tersebut dapat berupa submodul (atau subpaket) dari paket, atau
beberapa nama lain yang ditentukan dalam paket, seperti fungsi, kelas
atau variabel. Pernyataan "import" pertama menguji apakah item
tersebut didefinisikan dalam paket; jika tidak, ini dianggap sebagai
modul dan mencoba memuatnya. Jika gagal menemukannya, pengecualian
"ImportError" dimunculkan.

Sebaliknya, ketika menggunakan sintaksis seperti "import
item.subitem.subsubitem", setiap item kecuali yang terakhir harus
berupa paket; item terakhir dapat berupa modul atau paket tetapi tidak
bisa berupa kelas atau fungsi atau variabel yang didefinisikan dalam
item sebelumnya.


6.4.1. Mengimpor * Dari Paket
-----------------------------

Sekarang apa yang terjadi ketika pengguna menulis "from sound.effects
import *"? Idealnya, orang akan berharap bahwa ini entah bagaimana
keluar ke sistem file, menemukan submodul mana yang ada dalam paket,
dan mengimpor semuanya. Ini bisa memakan waktu lama dan mengimpor
submodul mungkin memiliki efek samping yang tidak diinginkan yang
seharusnya hanya terjadi ketika submodul diimpor secara eksplisit.

Satu-satunya solusi adalah bagi pembuat paket untuk memberikan indeks
paket secara eksplisit. Pernyataan "import" menggunakan konvensi
berikut: jika suatu paket punya kode "__init __.py" yang
mendefinisikan daftar bernama "__all__", itu diambil sebagai daftar
nama modul yang harus diimpor ketika "from package import *"
ditemukan. Terserah pembuat paket untuk tetap memperbarui daftar ini
ketika versi baru dari paket dirilis. Pembuat paket juga dapat
memutuskan untuk tidak mendukungnya, jika mereka tidak melihat
penggunaan untuk mengimpor * dari paket mereka. Sebagai contoh, berkas
"sound/effects/__init__.py" dapat berisi kode berikut:

   __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.)

Meskipun modul-modul tertentu dirancang hanya untuk mengekspor nama-
nama yang mengikuti pola tertentu ketika Anda menggunakan "import *",
itu masih dianggap praktik buruk dalam lingkungan kode produksi
*production*.

Ingat, tidak ada yang salah dengan menggunakan "from package import
specific_submodule"! Sebenarnya, ini adalah notasi yang disarankan
kecuali modul impor perlu menggunakan submodul dengan nama yang sama
dari paket yang berbeda.


6.4.2. Referensi Intra-paket
----------------------------

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

Perhatikan bahwa impor relatif didasarkan pada nama modul saat ini.
Karena nama modul utama selalu ""__main__"", modul yang dimaksudkan
untuk digunakan sebagai modul utama aplikasi Python harus selalu
menggunakan impor absolut.


6.4.3. Paket di Beberapa Direktori
----------------------------------

Paket mendukung satu atribut khusus lagi, "__path__". Ini
diinisialisasi menjadi daftar yang berisi nama direktori yang
menyimpan file paket: *__init__.py* sebelum kode dalam file tersebut
dieksekusi. Variabel ini dapat dimodifikasi; hal itu memengaruhi
pencarian modul dan subpackage di masa depan yang terkandung dalam
paket.

Meskipun fitur ini tidak sering dibutuhkan, fitur ini dapat digunakan
untuk memperluas rangkaian modul yang ditemukan dalam suatu paket.

-[ Catatan kaki ]-

[1] In fact function definitions are also 'statements' that are
    'executed'; the execution of a module-level function definition
    adds the function name to the module's global namespace.
