6. Modules
**********

Εάν βγείτε από τον interpreter της Python και μπείτε ξανά, οι ορισμοί
που έχετε κάνει (συναρτήσεις και μεταβλητές) χάνονται.  Επομένως, εάν
θέλετε να γράψετε ένα κάπως μεγαλύτερο πρόγραμμα, είναι προτιμότερο να
χρησιμοποιήσετε έναν επεξεργαστή κειμένου για να προετοιμάσετε την
εισαγωγή για τον interpreter και την εκτέλεση του με αυτό το αρχείο ως
input.  Αυτό είναι γνωστό ως δημιουργία *script*.  Καθώς το πρόγραμμα
σας μεγαλώνει, μπορεί να θέλετε να το χωρίσετε σε πολλά αρχεία για
ευκολότερη συντήρηση.  Μπορεί επίσης να θέλετε να χρησιμοποιήσετε μια
εύχρηστη συνάρτηση που έχετε γράψει σε πολλά προγράμματα χωρίς να
αντιγράψετε τον ορισμό της σε κάθε πρόγραμμα.

Για να το υποστηρίξει αυτό, η Python έχει έναν τρόπο να βάζει ορισμούς
σε ένα αρχείο και να τους χρησιμοποιεί σε ένα script ή σε ένα
διαδραστικό instance του interpreter.  Ένα τέτοιο αρχείο ονομάζεται
*module*∙ ορισμοί από μια ενότητα μπορούν να *εισαχθούν* σε άλλα
modules ή στο *κύριο* module (η συλλογή των μεταβλητών στις οποίες
έχετε πρόσβαση σε ένα script που εκτελείται στον ανώτερο επίπεδο και
σε λειτουργία αριθμομηχανής).

Ένα module είναι ένα αρχείο που περιέχει ορισμούς και δηλώσεις Python.
Το όνομα αρχείου είναι το όνομα του module με το επίθημα ".py".  Μέσε
σε ένα module, το όνομα του module (ως συμβολοσειρά) είναι διαθέσιμο
ως τιμή της global μεταβλητής "__name__".  Για παράδειγμα,
χρησιμοποιήστε το αγαπημένος σας πρόγραμμα επεξεργασίας κειμένου για
να δημιουργήσετε ένα αρχείο που ονομάζεται "fibo.py" στον τρέχοντα
κατάλογο με τα ακόλουθα περιεχόμενα:

   # 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

Τώρα εισάγετε τον Python interpreter και εισάγετε αυτό το module με
την ακόλουθη εντολή:

   >>> import fibo

This does not enter the names of the functions defined in "fibo"
directly in the current symbol table; it only enters 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'

Εάν σκοπεύετε να χρησιμοποιείτε συχνά μια συνάρτηση, μπορείτε να την
αντιστοιχίσετε σε ένα τοπικό όνομα:

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


6.1. Περισσότερα για τα Modules
===============================

Ένα module μπορεί να περιέχει εκτελέσιμες δηλώσεις καθώς και ορισμούς
συναρτήσεων. Αυτές οι δηλώσεις προορίζονται για την προετοιμασία του
module. Εκτελούνται μόνο την *πρώτη* φορά που εμφανίζεται το όνομα του
module σε μια δήλωση εισαγωγής. [1] (Εκτελούνται επίσης εάν το αρχείο
εκτελείται ως script.)

Each module has its own private symbol table, which is used as the
global symbol table 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 are placed in the
importing module's global symbol table.

There is a variant of the "import" statement that imports names from a
module directly into the importing module's symbol table.  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 symbol table (so in the example, "fibo" is not
defined).

Υπάρχει ακόμη και μια παραλλαγή για την εισαγωγή όλων των ονομάτων που
ορίζει μια ενότητα:

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

Αυτό εισάγει όλα τα ονόματα εκτός από αυτά που ξεκινούν με κάτω παύλα
("_"). Στις περισσότερες περιπτώσεις, οι προγραμματιστές Python δεν
χρησιμοποιούν αυτήν την δυνατότητα , καθώς εισάγει ένα άγνωστο σύνολο
ονομάτων στον interpreter, κρύβοντας πιθανώς κάποια πράγματα που έχετε
ήδη ορίσει.

Λάβετε υπόψη ότι γενικά η πρακτική της εισαγωγής "*" από ένα module ή
ένα πακέτο αποδοκιμάζεται, καθώς προκαλεί συχνά κακώς αναγνώσιμο
κώδικα. Ωστόσο, είναι εντάξει να τον χρησιμοποιήσετε για να
αποθηκεύσετε την πληκτρολόγηση σε διαδραστικές περιόδους σύνδεσης.

Εάν το όνομα του module ακολουθείται από "as", τότε το όνομα που
ακολουθεί "as" συνδέεται απευθείας με το εισαγόμενο module.

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

Αυτό ουσιαστικά εισάγει το module με τον ίδιο τρόπο που θα κάνει το
"import fibo" , με τη μόνη διαφορά ότι είναι διαθέσιμο ως "fib".

Μπορεί επίσης να χρησιμοποιηθεί όταν χρησιμοποιείτε "from" με παρόμοια
εφέ:

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

Σημείωση:

  Για λόγους αποτελεσματικότητας, κάθε module εισάγεται μόνο μία φορά
  ανά περίοδο λειτουργίες του interpreter.  Επομένως, εάν αλλάξετε τα
  modules σας, πρέπει να επανεκκινήσετε τον διερμηνέα -- ή, εάν είναι
  μόνο ένα module που θέλετε να δοκιμάσετε διαδραστικά, χρησιμοποιήστε
  το "importlib.reload()", π.χ. "import importlib;
  importlib.reload(modulename)".


6.1.1. Εκτέλεση modules ως scripts
----------------------------------

Όταν εκτελείτε ένα Python module με:

   python fibo.py <arguments>

ο κώδικας στο module θα εκτελεστεί, ακριβώς σαν να τον εισαγάγετε,
αλλά με το "name" να έχει οριστεί σε ""__main__"".  Αυτό σημαίνει ότι
προσθέτοντας αυτόν τον κώδικα στο τέλος του module σας:

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

μπορείτε να κάνετε το αρχείο χρησιμοποιήσιμο ως script καθώς και ως
module που μπορεί να εισαχθεί, επειδή ο κώδικας που αναλύει την γραμμή
εντολών εκτελείται μόνο εάν το module εκτελείται ως το "main" αρχείο:

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

Εάν το module έχει εισαχθεί, ο κώδικας δεν εκτελείται:

   >>> import fibo
   >>>

Αυτό χρησιμοποιείται συχνά είτε για την παροχή ενός βολικού user
interface σε ένα module, είτε για σκοπούς δοκιμής (η εκτέλεση του
module ως script εκτελεί μια δοκιμαστική σουίτα).


6.1.2. Το Search Path του Module
--------------------------------

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:

* Ο κατάλογος που περιέχει το input script (ή τον τρέχοντα κατάλογο
  όταν δεν έχει καθοριστεί αρχείο).

* "PYTHONPATH" (μια λίστα ονομάτων καταλόγου, με την ίδια σύνταξη με
  τη μεταβλητή του shell "PATH").

* Η προεπιλογή που εξαρτάται από την εγκατάσταση (κατά σύμβαση,
  συμπεριλαμβανομένου ενός καταλόγου "site-packages", που χειρίζεται
  το module "site".

Σημείωση:

  Στα συστήματα αρχείων που υποστηρίζουν symlinks, ο κατάλογο που
  περιέχει το input script υπολογίζεται αφού ακολουθηθεί το symlink.
  Με άλλα λόγια, ο κατάλογος που περιέχει το symlink **δεν**
  προστίθεται στη διαδρομή αναζήτησης του module.

Μετά την προετοιμασία, τα προγράμματα Python μπορούν να τροποποιήσουν
το "sys.path".  Ο κατάλογος που περιέχει το script που εκτελείται
τοποθετείται στην αρχή της διαδρομής αναζήτησης , μπροστά από την
τυπική διαδρομή της βιβλιοθήκης. Αυτό σημαίνει ότι τα scripts σε αυτόν
τον κατάλογο θα είναι φορτωμένα αντί για τα modules με το ίδιο όνομα
στον κατάλογο μιας βιβλιοθήκης. Αυτό είναι ένα σφάλμα, εκτός εάν
προορίζεται η αντικατάσταση.  Βλ. την ενότητα Standard Modules για
περισσότερες πληροφορίες.


6.1.3. "Compiled" Python αρχεία
-------------------------------

Για να επιταχύνει τη φόρτωση modules, η Python κάνει cache την
compiled έκδοση κάθε module στον κατάλογο "__pycache__" κάτω από το
όνομα "module.*version*.pyc", όπου η έκδοση κωδικοποιεί τη μορφή του
compiled αρχείου∙ γενικά περιέχει τον αριθμό έκδοσης της Python.  Για
παράδειγμα, στην έκδοση CPython 3.3 η compiled έκδοση του spam.py θα
αποθηκευτεί ως "__pycache__/spam.cpython-33.pyc".  Αυτή η σύμβαση
ονομασίας, επιτρέπει σε compiled modules από διαφορετικές εκδόσεις και
διαφορετικές εκδόσεις της Python να συνυπάρχουν.

Η Python ελέγχει την ημερομηνία τροποποίησης του πηγαίου έναντι της
compiled έκδοσης για να δει εάν είναι ξεπερασμένη και χρειάζεται να
γίνει compile ξανά.  Αυτή είναι μια εντελώς αυτόματη διαδικασία.
Επίσης, τα compiled modules είναι ανεξάρτητες από πλατφόρμα, επομένως
η ίδια βιβλιοθήκη μπορεί να κοινοποιηθεί ανάμεσα σε συστήματα με
διαφορετικές αρχιτεκτονικές.

Η Python δεν ελέγχει την cache σε δύο περιπτώσεις.  Πρώτον, πάντα
κάνει compile ξανά και δεν αποθηκεύει το αποτέλεσμα για το module που
φορτώνεται απευθείας από τη γραμμή εντολών.  Δεύτερον, δεν ελέγχει τη
μνήμη cache εάν δεν υπάρχει το source module.  Για να υποστηρίξετε μια
διανομή χωρίς πηγαίο (compiled μόνο), το compiled module πρέπει να
βρίσκεται στον source κατάλογο και δεν πρέπει να υπάρχει source
module.

Μερικές συμβουλές για ειδικούς:

* Μπορείτε να χρησιμοποιήσετε τους switches "-O" ή "-OO" στην εντολή
  Python για να μειώσετε το μέγεθος ενός compiled module.  Το "-O"
  switch αφαιρεί τις assert statements, το "-OO" switch αφαιρεί τόσο
  τα assert statements όσο και τις __doc__ συμβολοσειρές . Εφόσον
  ορισμένα προγράμματα μπορεί να βασίζονται στην ύπαρξη αυτών των
  διαθέσιμων, θα πρέπει να χρησιμοποιήσετε αυτήν την επιλογή μόνο εάν
  γνωρίζετε τι κάνετε.  "Optimized" modules έχουν ένα "opt-" tag και
  είναι συνήθως μικρότερες.  Οι μελλοντικές εκδόσεις μπορεί να
  αλλάξουν τα αποτελέσματα της βελτιστοποίησης.

* Ένα πρόγραμμα δεν εκτελείται πιο γρήγορα όταν διαβάζεται από ένα
  αρχείο ".pyc" από ό,τι όταν διαβάζεται από ένα αρχείο ".py``∙ το
  μόνο πράγμα που είναι πιο γρήγορο από τα αρχεία ``.pyc" είναι η
  ταχύτητα με την οποία φορτώνονται.

* Το module "compileall" μπορεί να δημιουργήσει αρχεία .pyc για όλα τα
  modules σε ένα κατάλογο.

* Υπάρχουν περισσότερες λεπτομέρειες σχετικά με αυτή τη διαδικασία,
  συμπεριλαμβανομένου ενός διαγράμματος ροής των αποφάσεων, στο **PEP
  3147**.


6.2. Standard Modules
=====================

Η Python συνοδεύεται από μια βιβλιοθήκη standard modules, η οποία
περιγράφεται σε ένα ξεχωριστό έγγραφο, την Αναφορά Βιβλιοθήκης Python
("Library Reference" hereafter).  Ορισμένα modules είναι ενσωματωμένα
στον interpreter∙ αυτές παρέχουν πρόσβαση σε λειτουργίες που δεν
αποτελούν μέρος του πυρήνα της γλώσσας, αλλά εντούτοις είναι
ενσωματωμένα, είτε για αποτελεσματικότητα είτε για την παροχή
πρόσβασης σε πρωτόγονα στοιχεία του λειτουργικού συστήματος όπως οι
κλήσεις συστήματος.  Το σύνολο τέτοιων modules είναι μια επιλογή
διαμόρφωσης που εξαρτάται επίσης από την υποκείμενη πλατφόρμα.  Για
παράδειγμα, το module "winreg" παρέχεται μόνο σε συστήματα Windows.
Ένα συγκεκριμένο module που αξίζει κάποια προσοχή είναι το "sys", το
οποίο είναι ενσωματωμένο στον interpreter της Python.  Οι μεταβλητές
"sys.ps1" και "sys.ps2" ορίζουν τις συμβολοσειρές που χρησιμοποιούνται
ως κύρια και δευτερεύοντα prompts:

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

Αυτές οι δύο μεταβλητές ορίζονται μόνο εάν ο interpreter βρίσκεται σε
διαδραστική λειτουργία.

Η μεταβλητή "sys.path" είναι μια λίστα συμβολοσειρών που καθορίζει τη
διαδρομή αναζήτησης του διερμηνέα για modules. Αρχικοποιείται σε μια
προεπιλεγμένη διαδρομή που λαμβάνεται από τη μεταβλητή περιβάλλοντος
"PYTHONPATH", ή από μια ενσωματωμένη προεπιλογή εάν το "PYTHONPATH"
δεν έχει οριστεί.  Μπορείτε να το τροποποιήσετε χρησιμοποιώντας
τυπικές λειτουργίες λίστας:

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


6.3. Η συνάρτηση "dir()"
========================

Η ενσωματωμένη συνάρτηση "dir()" χρησιμοποιείται για να ανακαλύψει
ποια ονόματα ορίζει ένα module.  Επιστρέφει μια ταξινομημένη λίστα
συμβολοσειρών:

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

Χωρίς ορίσματα, η "dir()" παραθέτει τα ονόματα που έχετε ορίσει αυτήν
τη στιγμή:

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

Λάβετε υπόψη ότι παραθέτει όλους τους τύπους ονομάτων: μεταβλητές,
modules, συναρτήσεις, κ.λπ.

Η "dir()" δεν παραθέτει τα ονόματα των ενσωματωμένων συναρτήσεων και
μεταβλητών.  Εάν θέλετε μια λίστα από αυτές, ορίζονται στην τυπική
ενότητα "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. Πακέτα
===========

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.

Ας υποθέσουμε ότι θέλετε να σχεδιάσετε μια συλλογή από module (ένα
"πακέτο") για τον ομοιόμορφο χειρισμό αρχείων ήχου και δεδομένων ήχου.
Υπάρχουν πολλές διαφορετικές μορφές αρχείων ήχου (που συνήθως
αναγνωρίζονται από την επέκτασή τους, για παράδειγμα: ".wav", ".aiff",
".au"), επομένως μπορεί να χρειαστεί να δημιουργήσετε και να
διατηρήσετε μια αυξανόμενη συλλογή λειτουργιών για τη μετατροπή μεταξύ
των διαφόρων μορφών αρχείων. Υπάρχουν επίσης πολλές διαφορετικές
λειτουργίες που μπορεί να θέλετε να εκτελέσετε σε δεδομένα ήχου (όπως
μίξη, προσθήκη ηχούς, εφαρμογή μιας λειτουργίας ισοσταθμιστή,
δημιουργία τεχνητού στερεοφωνικού εφέ), επομένως επιπλέον θα γράφετε
μια ατελείωτη ροή από modules για να εκτελέσετε αυτές τις λειτουργίες.
Ακολουθεί μια πιθανή δομή για το πακέτο σας (που εκφράζεται ως
ιεραρχικό σύστημα αρχείων):

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

Κατά την εισαγωγή του πακέτου, η Python πραγματοποιεί αναζήτηση στους
καταλόγους στο "sys.path" αναζητώντας τον υποκατάλογο του πακέτου.

The "__init__.py" files are required to make Python treat directories
containing the file as packages.  This prevents directories with a
common name, such as "string", 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.

Οι χρήστες του πακέτου μπορούν να εισάγουν μεμονωμένα module από το
πακέτο, για παράδειγμα:

   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)

Ένα εναλλακτικός τρόπος για την εισαγωγή του submodule είναι:

   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)

Μια άλλη παραλλαγή είναι η απευθείας εισαγωγή της επιθυμητής
συνάρτησης ή μεταβλητής:

   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", το
στοιχείο μπορεί να είναι είτε submodule (ή υποπακέτο) του πακέτου ή
κάποιο άλλο όνομα που ορίζεται στο πακέτο, όπως μια συνάρτηση, κλάση ή
μεταβλητή. Η "import" δήλωση ελέγχει πρώτα εάν το στοιχείο έχει
οριστεί στο πακέτο, εάν όχι, υποθέτει ότι είναι ένα module και
επιχειρεί να το φορτώσει , αν δεν το βρει δημιουργεί η εξαίρεση
"ImportError".

Αντίθετα, όταν χρησιμοποιείται σύνταξη όπως "import
item.subitem.subsubitem", κάθε στοιχείο εκτός από αυτό το τελευταίο
πρέπει να είναι πακέτο∙ το τελευταίο στοιχείο μπορεί να είναι ένα
module ή ένα πακέτο αλλά δεν μπορεί να είναι μια κλάση ή συνάρτηση ή
μεταβλητή που ορίζεται από προηγούμενο στοιχείο.


6.4.1. Εισάγοντας * από ένα Πακέτο
----------------------------------

Τώρα τι συμβαίνει όταν ο χρήστης γράφει "from sound.effects import *";
Ιδανικά, θα ήλπιζε κανείς ότι αυτό θα βγει με κάποιο τρόπο στο σύστημα
αρχείων, θα βρει κάποια submodules που υπάρχουν το πακέτο, και θα τα
εισάγει όλα σε αυτό.  Αυτό θα μπορούσε να πάρει πολύ χρόνο και η
εισαγωγή submodules μπορεί να έχει ανεπιθύμητες παρενέργειες που θα
έπρεπε να συμβούν όταν το submodule εισάγεται ρητά.

Η μόνη λύση είναι να παρέχει ο συντάκτης του πακέτου ένα ρητό
ευρετήριο του πακέτου.  Η δήλωση "import" χρησιμοποιεί την ακόλουθη
σύμβαση: εάν ο κώδικας "__init__.py" του πακέτου ορίζει μια λίστα με
το όνομα "__all__", θεωρείται ότι είναι η λίστα με τα ονόματα των
modules που θα πρέπει να εισαχθούν όταν συναντήσετε "from package
import *".  Είναι στην διακριτή ευχέρεια του συντάκτη του πακέτου να
διατηρεί αυτή τη λίστα ενημερωμένη, όταν κυκλοφορήσει μια νέα έκδοση
του πακέτου.  Οι συντάκτες του πακέτου ενδέχεται επίσης να αποφασίσουν
να μην το υποστηρίξουν, εάν δεν βλέπουν ότι χρησιμοποιείται η εισαγωγή
του * από το πακέτο τους.  Για παράδειγμα το αρχείο
"sound/effects/__init__.py" θα μπορούσε να περιέχει τον ακόλουθο
κώδικα:

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

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

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

Αν και ορισμένα modules έχουν σχεδιαστεί για να εξάγουν μόνο ονόματα
που ακολουθούν ορισμένα μοτίβα όταν χρησιμοποιείτε το "import *",
εξακολουθεί να θεωρείται κακή πρακτική στον κώδικα παραγωγής.

Θυμηθείτε, δεν υπάρχει τίποτα κακό με τη χρήση του "from package
import specific_submodule"!  Στην πραγματικότητα, αυτή είναι η
προτεινόμενη σημείωση, εκτός εάν το module εισαγωγής χρειάζεται να
χρησιμοποιήσει submodules με το ίδιο όνομα από διαφορετικά πακέτα.


6.4.2. Intra-package αναφορές
-----------------------------

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

Λάβετε υπόψη ότι οι σχετικές εισαγωγές βασίζονται στο όνομα του
τρέχοντος module.  Επειδή το όνομα του κύριου module είναι πάντα
""__main__"", τα modules που προορίζονται για χρήση ως κύριο module
μιας εφαρμογής Python πρέπει πάντα να χρησιμοποιούν απόλυτες
εισαγωγές.


6.4.3. Πακέτα σε Πολλαπλούς Καταλόγους
--------------------------------------

Packages support one more special attribute, "__path__".  This is
initialized to be a list containing the name of the directory holding
the package's "__init__.py" before the code in that file is executed.
This variable can be modified; doing so affects future searches for
modules and subpackages contained in the package.

Ενώ αυτή η δυνατότητα δεν χρειάζεται συχνά, μπορεί να χρησιμοποιηθεί
για την επέκταση του συνόλου των modules που βρίσκονται σε ένα πακέτο.

-[ Υποσημειώσεις ]-

[1] In fact function definitions are also 'statements' that are
    'executed'; the execution of a module-level function definition
    enters the function name in the module's global symbol table.
