6. 모듈
*******

파이썬 인터프리터를 종료한 후에 다시 들어가면, 여러분이 만들었던 정의
들이 사라집니다 (함수나 변수들). 그래서, 좀 긴 프로그램을 쓰고자 한다
면, 대신 인터프리터 입력을 편집기를 사용해서 준비한 후에 그 파일을 입
력으로 사용해서 실행하는 것이 좋습니다. 이렇게 하는 것을 *스크립트* 를
만든다고 합니다. 프로그램이 길어짐에 따라, 유지를 쉽게 하려고 여러 개
의 파일로 나누고 싶을 수 있습니다. 여러 프로그램에서 썼던 편리한 함수
를 각 프로그램에 정의를 복사하지 않고도 사용하고 싶을 수도 있습니다.

이런 것을 지원하기 위해, 파이썬은 정의들을 파일에 넣고 스크립트나 인터
프리터의 대화형 모드에서 사용할 수 있는 방법을 제공합니다. 그런 파일을
*모듈* 이라고 부릅니다; 모듈로부터 정의들이 다른 모듈이나 *메인* 모듈
로 *임포트* 될 수 있습니다 (메인 모듈은 최상위 수준에서 실행되는 스크
립트나 계산기 모드에서 액세스하는 변수들의 컬렉션입니다).

모듈은 파이썬 정의와 문장들을 담고 있는 파일입니다. 파일의 이름은 모듈
이름에 확장자 ".py" 를 붙입니다. 모듈 내에서, 모듈의 이름은 전역 변수
"__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

이제 파이썬 인터프리터에 들어가서 이 모듈을 다음과 같은 명령으로 임포
트 합니다:

   >>> import fibo

이렇게 한다고 "fibo" 에 정의된 함수들의 이름이 현재 심볼 테이블에 직접
들어가지는 않습니다; 오직 모듈 이름 "fibo" 만 들어갈 뿐입니다. 이 모듈
이름을 사용해서 함수들을 액세스할 수 있습니다:

   >>> 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. 모듈 더 보기
=================

모듈은 함수 정의뿐만 아니라 실행 가능한 문장들도 포함할 수 있습니다.
이 문장들은 모듈을 초기화하는 데 사용됩니다. 이것들은 임포트 문에서 모
듈 이름이 *처음* 등장할 때만 실행됩니다. [1] (이것들은 파일이 스크립트
로 실행될 때도 실행됩니다.)

각 모듈은 자신만의 심볼 테이블을 갖고 있는데, 그 모듈에서 정의된 함수
들의 전역 심볼 테이블로 사용됩니다. 그래서, 모듈의 저자는 사용자의 전
역 변수와 우연히 충돌할 것을 걱정하지 않고 전역 변수를 사용할 수 있습
니다. 반면에, 여러분이 무얼 하는지 안다면, 모듈의 함수를 참조하는데 사
용된 것과 같은 표기법으로 모듈의 전역 변수들을 건드릴 수 있습니다,
"modname.itemname".

모듈은 다른 모듈들을 임포트할 수 있습니다. 모든 "import" 문들을 모듈의
처음에 놓는 것이 관례지만 반드시 그래야 하는 것은 아닙니다 (그 점에 관
한 한 스크립트도 마찬가집니다). 임포트되는 모듈 이름은 임포트하는 모듈
의 전역 심볼 테이블에 들어갑니다.

모듈에 들어있는 이름들을 직접 임포트하는 모듈의 심볼 테이블로 임포트하
는 "import" 문의 변종이 있습니다. 예를 들어:

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

이것은 지역 심볼 테이블에 임포트되는 모듈의 이름을 만들지 않습니다 (그
래서 이 예에서는, "fibo" 가 정의되지 않습니다).

모듈이 정의하는 모든 이름을 임포트하는 변종도 있습니다:

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

이것은 밑줄 ("_") 로 시작하는 것들을 제외한 모든 이름을 임포트 합니다.
대부분 파이썬 프로그래머들은 이 기능을 사용하지 않는데, 인터프리터로
알려지지 않은 이름들의 집합을 도입하게 되어, 여러분이 이미 정의한 것들
을 가리게 될 수 있기 때문입니다.

일반적으로 모듈이나 패키지에서 "*" 를 임포트하는 것은 눈살을 찌푸리게
한다는 것에 유의하세요, 종종 읽기에 편하지 않은 코드를 만들기 때문입니
다. 하지만, 대화형 세션에서 입력을 줄이고자 사용하는 것은 상관없습니다
.

모듈 이름 다음에 "as" 가 올 경우, "as" 다음의 이름을 임포트한 모듈에
직접 연결합니다.

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

이것은 "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

참고:

  효율성의 이유로, 각 모듈은 인터프리터 세션마다 한 번만 임포트됩니다.
  그래서, 여러분이 모듈을 수정하면, 인터프리터를 다시 시작시켜야 합니
  다 --- 또는, 대화형으로 시험하는 모듈이 하나뿐이라면,
  "importlib.reload()" 를 사용하세요. 예를 들어, "import importlib;
  importlib.reload(modulename)".


6.1.1. 모듈을 스크립트로 실행하기
---------------------------------

여러분이 파이썬 모듈을 이렇게 실행하면

   python fibo.py <arguments>

모듈에 있는 코드는, 그것을 임포트할 때처럼 실행됩니다. 하지만
"__name__" 은 ""__main__"" 로 설정됩니다. 이것은, 이 코드를 모듈의 끝
에 붙여서:

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

파일을 임포트할 수 있는 모듈뿐만 아니라 스크립트로도 사용할 수 있도록
만들 수 있음을 의미하는데, 오직 모듈이 "메인" 파일로 실행될 때만 명령
행을 파싱하는 코드가 실행되기 때문입니다:

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

모듈이 임포트될 때, 코드는 실행되지 않습니다:

   >>> import fibo
   >>>

이것은 종종 모듈에 대한 편리한 사용자 인터페이스를 제공하거나 테스트
목적으로 사용됩니다 (모듈을 스크립트로 실행하면 테스트 스위트를 실행하
기).


6.1.2. 모듈 검색 경로
---------------------

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:

* 입력 스크립트를 포함하는 디렉터리 (또는 파일이 지정되지 않았을 때는
  현재 디렉터리).

* "PYTHONPATH" (디렉터리 이름들의 목록, 셸 변수 "PATH" 와 같은 문법).

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

참고:

  심볼릭 링크를 지원하는 파일 시스템에서, 입력 스크립트를 포함하는 디
  렉터리는 심볼릭 링크를 변환한 후에 계산됩니다. 다른 말로, 심볼릭 링
  크를 포함하는 디렉터리는 모듈 검색 경로에 포함되지 **않습니다**.

초기화 후에, 파이썬 프로그램은 "sys.path" 를 수정할 수 있습니다. 스크
립트를 포함하는 디렉터리는 검색 경로의 처음에, 표준 라이브러리 경로의
앞에 놓입니다. 이것은 같은 이름일 경우 라이브러리 디렉터리에 있는 것
대신 스크립트를 포함하는 디렉터리의 것이 로드된다는 뜻입니다. 이 치환
이 의도된 것이 아니라면 에러입니다. 더 자세한 정보는 표준 모듈들 을 보
세요.


6.1.3. "컴파일된" 파이썬 파일
-----------------------------

모듈 로딩을 빠르게 하려고, 파이썬은 "__pycache__" 디렉터리에 각 모듈의
컴파일된 버전을 "module.*version*.pyc" 라는 이름으로 캐싱합니다.
version 은 컴파일된 파일의 형식을 지정합니다; 일반적으로 파이썬의 버전
번호를 포함합니다. 예를 들어, CPython 배포 3.3 에서 spam.py 의 컴파일
된 버전은 "__pycache__/spam.cpython-33.pyc" 로 캐싱 됩니다. 이 명명법
은 서로 다른 파이썬 배포와 버전의 컴파일된 모듈들이 공존할 수 있도록
합니다.

파이썬은 소스의 수정 시간을 컴파일된 버전과 비교해서 시효가 지나 다시
컴파일해야 하는지 검사합니다. 이것은 완전히 자동화된 과정입니다. 또한,
컴파일된 모듈은 플랫폼 독립적이기 때문에, 같은 라이브러리를 서로 다른
아키텍처를 갖는 시스템들에서 공유할 수 있습니다.

파이썬은 두 가지 상황에서 캐시를 검사하지 않습니다. 첫째로, 명령행에서
직접 로드되는 모듈들은 항상 재컴파일하고 그 결과를 저장하지 않습니다.
둘째로, 소스 모듈이 없으면 캐시를 검사하지 않습니다. 소스 없는 (컴파일
된 파일만 있는) 배포를 지원하려면, 컴파일된 모듈이 소스 디렉터리에 있
어야 하고, 소스 모듈이 없어야 합니다.

전문가를 위한 몇 가지 팁

* 컴파일된 모듈의 크기를 줄이려면 파이썬 명령에 "-O" 나 "-OO" 스위치를
  사용할 수 있습니다. "-O" 스위치는 assert 문을 제거하고, "-OO" 스위치
  는 assert 문과 __doc__ 문자열을 모두 제거합니다. 어떤 프로그램들은
  이것들에 의존하기 때문에, 무엇을 하고 있는지 아는 경우만 이 옵션을
  사용해야 합니다. "최적화된" 모듈은 "opt-" 태그를 갖고, 보통 더 작습
  니다. 미래의 배포에서는 최적화의 효과가 변경될 수 있습니다.

* ".py" 파일에서 읽을 때보다 ".pyc" 파일에서 읽을 때 프로그램이 더 빨
  리 실행되지는 않습니다; ".pyc" 파일에서 더 빨라지는 것은 로드되는 속
  도뿐입니다.

* 모듈 "compileall" 은 디렉터리에 있는 모든 모듈의 .pyc 파일들을 만들
  수 있습니다.

* 이 절차에 대한 더 자세한 정보, 결정들의 순서도를 포함합니다, 는
  **PEP 3147** 에 나옵니다.


6.2. 표준 모듈들
================

파이썬은 표준 모듈들의 라이브러리가 함께 오는데, 별도의 문서 파이썬 라
이브러리 레퍼런스 (이후로는 "라이브러리 레퍼런스") 에서 설명합니다. 어
떤 모듈들은 인터프리터에 내장됩니다; 이것들은 언어의 핵심적인 부분은
아니지만 그런데도 내장된 연산들에 대한 액세스를 제공하는데, 효율이나
시스템 호출과 같은 운영 체제 기본 요소들에 대한 액세스를 제공하기 위함
입니다. 그런 모듈들의 집합은 설정 옵션인데 기반 플랫폼 의존적입니다.
예를 들어, "winreg" 모듈은 윈도우 시스템에서만 제공됩니다. 특별한 모듈
하나는 주목을 받을 필요가 있습니다: "sys". 모든 파이썬 인터프리터에 내
장됩니다. 변수 "sys.ps1" 와 "sys.ps2" 는 기본과 보조 프롬프트로 사용되
는 문자열을 정의합니다:

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

이 두 개의 변수들은 인터프리터가 대화형 모드일 때만 정의됩니다.

변수 "sys.path" 는 인터프리터의 모듈 검색 경로를 결정하는 문자열들의
리스트입니다. 환경 변수 "PYTHONPATH" 에서 취한 기본 경로나,
"PYTHONPATH" 가 설정되지 않는 경우 내장 기본값으로 초기화됩니다. 표준
리스트 연산을 사용해서 수정할 수 있습니다:

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


6.3. "dir()" 함수
=================

내장 함수 "dir()" 은 모듈이 정의하는 이름들을 찾는 데 사용됩니다. 문자
열들의 정렬된 리스트를 돌려줍니다:

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

모든 형의 이름을 나열한다는 것에 유의해야 합니다: 변수, 모듈, 함수, 등
등.

"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. 패키지
===========

패키지는 "점으로 구분된 모듈 이름" 를 써서 파이썬의 모듈 이름 공간을
구조화하는 방법입니다. 예를 들어, 모듈 이름 "A.B" 는 "A" 라는 이름의
패키지에 있는 "B" 라는 이름의 서브 모듈을 가리킵니다. 모듈의 사용이 다
른 모듈의 저자들이 서로의 전역 변수 이름들을 걱정할 필요 없게 만드는
것과 마찬가지로, 점으로 구분된 모듈의 이름들은 NumPy 나 Pillow 과 같은
다중 모듈 패키지들의 저자들이 서로의 모듈 이름들을 걱정할 필요 없게 만
듭니다.

음향 파일과 과 음향 데이터의 일관된 처리를 위한 모듈들의 컬렉션 ("패키
지") 을 설계하길 원한다고 합시다. 여러 종류의 음향 파일 형식이 있으므
로 (보통 확장자로 구분됩니다, 예를 들어: ".wav", ".aiff", ".au"), 다양
한 파일 형식 간의 변환을 위해 계속 늘어나는 모듈들의 컬렉션을 만들고
유지할 필요가 있습니다. 또한, 음향 데이터에 적용하고자 하는 많은 종류
의 연산들도 있으므로 (믹싱, 에코 넣기, 이퀄라이저 기능 적용, 인공적인
스테레오 효과 만들기와 같은), 이 연산들을 수행하기 위한 모듈들을 끊임
없이 작성하게 될 것입니다. 패키지를 이렇게 구성해 볼 수 있습니다 (계층
적 파일 시스템으로 표현했습니다):

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

패키지를 임포트할 때, 파이썬은 "sys.path" 에 있는 디렉터리들을 검색하
면서 패키지 서브 디렉터리를 찾습니다.

파이썬이 디렉터리를 패키지로 취급하게 만들기 위해서 "__init__.py" 파일
이 필요합니다. 이렇게 하면 "string" 처럼 흔히 쓰는 이름의 디렉터리가,
의도하지 않게 모듈 검색 경로의 뒤에 등장하는 올바른 모듈들을 가리는 일
을 방지합니다. 가장 간단한 경우, "__init__.py" 는 그냥 빈 파일일 수 있
지만, 패키지의 초기화 코드를 실행하거나 뒤에서 설명하는 "__all__" 변수
를 설정할 수 있습니다.

패키지 사용자는 패키지로부터 개별 모듈을 임포트할 수 있습니다, 예를 들
어:

   import sound.effects.echo

이것은 서브 모듈 "sound.effects.echo" 를 로드합니다. 전체 이름으로 참
조되어야 합니다.

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

서브 모듈을 임포트하는 다른 방법은 이렇습니다:

   from sound.effects import echo

이것도 서브 모듈 "echo" 를 로드하고, 패키지 접두어 없이 사용할 수 있게
합니다. 그래서 이런 식으로 사용할 수 있습니다:

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

또 다른 방법은 원하는 함수나 변수를 직접 임포트하는 것입니다:

   from sound.effects.echo import echofilter

또다시, 이것은 서브 모듈 "echo" 를 로드하지만, 함수 "echofilter()" 를
직접 사용할 수 있게 만듭니다:

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

"from package import item" 를 사용할 때, item은 패키지의 서브 모듈 (또
는 서브 패키지)일 수도 있고 함수, 클래스, 변수 등 패키지에 정의된 다른
이름들일 수도 있음에 유의하세요. "import" 문은 먼저 item이 패키지에 정
의되어 있는지 검사하고, 그렇지 않으면 모듈이라고 가정하고 로드를 시도
합니다. 찾지 못한다면, "ImportError" 예외를 일으킵니다.

이에 반하여, "import item.subitem.subsubitem" 와 같은 문법을 사용할 때
, 마지막 것을 제외한 각 항목은 반드시 패키지여야 합니다; 마지막 항목은
모듈이나 패키지가 될 수 있지만, 앞의 항목에서 정의된 클래스, 함수, 변
수 등이 될 수는 없습니다.


6.4.1. 패키지에서 * 임포트 하기
-------------------------------

이제 "from sound.effects import *" 라고 쓰면 어떻게 될까? 이상적으로는
, 어떻게든 파일 시스템에서 패키지에 어떤 모듈들이 들어있는지 찾은 다음
, 그것들 모두를 임포트 하기를 원할 것입니다. 이렇게 하는 데는 시간이
오래 걸리고 서브 모듈을 임포트 함에 따라 어떤 서브 모듈을 명시적으로
임포트할 경우만 일어나야만 하는 원하지 않는 부수적 효과가 발생할 수 있
습니다.

유일한 해결책은 패키지 저자가 패키지의 색인을 명시적으로 제공하는 것입
니다. "import" 문은 다음과 같은 관례가 있습니다: 패키지의
"__init__.py" 코드가 "__all__" 이라는 이름의 목록을 제공하면, 이것을
"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.

"__all__" 이 정의되지 않으면, 문장 "from sound.effects import *" 은 패
키지 "sound.effects" 의 모든 서브 모듈들을 현재 이름 공간으로 임포트
하지 *않습니다*; 이것은 오직 패키지 "sound.effects" 가 임포트 되도록
만들고 ("__init__.py" 에 있는 초기화 코드들이 수행될 수 있습니다), 그
패키지가 정의하는 이름들을 임포트 합니다. 이 이름들은 "__init__.py" 가
정의하는 모든 이름 (그리고 명시적으로 로드된 서브 모듈들)을 포함합니다
. 이 이름들에는 사전에 "import" 문으로 명시적으로 로드된 패키지의 서브
모듈들 역시 포함됩니다. 이 코드를 생각해봅시다:

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

이 예에서, "echo" 와 "surround" 모듈이 현재 이름 공간으로 임포트 되는
데, "from...import" 문이 실행될 때 "sound.effects" 패키지에 정의되기
때문입니다. ("__all__" 이 정의될 때도 마찬가집니다.)

설사 어떤 모듈이 "import *" 를 사용할 때 특정 패턴을 따르는 이름들만
익스포트 하도록 설계되었다 하더라도, 프로덕션 코드에서는 여전히 좋지
않은 사례로 여겨집니다.

"from package import specific_submodule" 을 사용하는데 잘못된 것은 없
다는 것을 기억하세요! 사실, 임포트하는 모듈이 다른 패키지에서 같은 이
름의 서브 모듈을 사용할 필요가 없는 한 권장되는 표기법입니다.


6.4.2. 패키지 내부 간의 참조
----------------------------

패키지가 서브 패키지들로 구조화될 때 (예에서 나온 "sound" 패키지처럼),
이웃 패키지의 서브 모듈을 가리키는데 절대 임포트를 사용할 수 있습니다.
예를 들어, 모듈 "sound.filters.vocoder" 이 "sound.effects" 패키지의
"echo" 모듈이 필요하면, "from sound.effects import echo" 를 사용할 수
있습니다.

상대 임포트를 쓸 수도 있는데, "from module import name" 형태의 임포트
문을 사용합니다. 이 임포트는 상대 임포트에 수반되는 현재와 부모 패키지
를 가리키기 위해 앞에 붙는 점을 사용합니다. 예를 들어, "surround" 모듈
에서, 이렇게 사용할 수 있습니다:

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

상대 임포트가 현재 모듈의 이름에 기반을 둔다는 것에 주의하세요. 메인
모듈의 이름은 항상 ""__main__"" 이기 때문에, 파이썬 응용 프로그램의 메
인 모듈로 사용될 목적의 모듈들은 반드시 절대 임포트를 사용해야 합니다.


6.4.3. 여러 디렉터리에 있는 패키지
----------------------------------

패키지는 특별한 어트리뷰트 하나를 더 지원합니다, "__path__". 이것은 패
키지의 "__init__.py" 파일을 실행하기 전에, 이 파일이 들어있는 디렉터리
의 이름을 포함하는 리스트로 초기화됩니다. 이 변수는 수정할 수 있습니다
; 그렇게 하면 그 이후로 패키지에 포함된 모듈과 서브 패키지를 검색하는
데 영향을 주게 됩니다.

이 기능이 자주 필요하지는 않지만, 패키지에서 발견되는 모듈의 집합을 확
장하는 데 사용됩니다.

-[ 각주 ]-

[1] 사실 함수 정의도 '실행' 되는 '문장' 입니다; 모듈 수준의 함수 정의
    를 실행하면 함수의 이름이 전역 심볼 테이블에 들어갑니다.
