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.