Python 2.7 기본 튜토리얼: 모듈

.. _tut-modules:

************************

모듈 모듈

************************

파이썬 인터프리터를 종료했다가 다시 입력하면 정의가

만든(함수와 변수)이 손실됩니다. 따라서

다소 긴 프로그램을 작성하려면 텍스트 편집기를 사용하여

입력을 준비하는 것이 좋습니다. 대신 해당 파일을 입력으로 사용하여 실행하는 것입니다.

프로그램이 길어질수록

여러 파일로 분할하는 것이 좋습니다. 더 쉬운 유지 관리를 위해

각 프로그램에 정의를 복사하지 않고

여러 프로그램에서 작성한 편리한 기능을 사용할 수도 있습니다.

종료하는 경우 Python 인터프리터가 다시 시작되면 이전에 생성된 모든 정의(변수 및 함수)가 손실됩니다. 따라서 장기간 저장될 프로그램을 작성하려면 텍스트 편집기를 사용하여

프로그램을 작성하고 저장된 파일을 인터프리터에 입력하는 것이 가장 좋습니다. 이것을 *스크립트* 생성이라고 부릅니다. 또는

프로그램이 길어지면 유지 관리를 더 쉽게 하기 위해 여러 파일로 분리할 수도 있습니다. 여러

프로그램에서 공통 함수를 사용하고 싶지만 해당 정의를 모든 프로그램에 복사하고 싶지는 않을 수도 있습니다.

이를 지원하기 위해 Python에는 정의를 파일에 넣고

스크립트나 인터프리터의 대화형 인스턴스에서 사용하는 방법이 있습니다. 이러한 파일을

이라고 합니다.

*모듈*; 모듈의 정의는 다른 모듈이나

*기본* 모듈(

에서 액세스할 수 있는 변수 모음)로 *가져올 수 있습니다. 최상위 수준 및 계산기 모드에서 실행되는 스크립트).

이러한 요구 사항을 충족하기 위해 Python은 파일, 스크립트 또는

인터프리터의 대화형 부분에서 정의를 얻는 방법을 제공합니다. 예제에 사용되었습니다. 이러한 파일을 *모듈*이라고 합니다. 모듈의 정의는 다른 모듈이나 기본 모듈로 *가져올 수 있습니다*

(스크립트가 실행될 때 호출할 수 있는 변수 세트는 다음 위치에 있습니다). 가장 고급이며

계산기 모드에서).

모듈은 Python 정의와 명령문을 포함하는 파일입니다.

모듈 이름에는 접미사 :file:`.py`가 추가됩니다.

모듈 이름(문자열)은 전역 변수

``__name__``의 값으로 사용할 수 있습니다. 예를 들어 즐겨 사용하는 텍스트 편집기를 사용하여

라는 파일을 만듭니다. :file:`fibo.py`는 다음 내용을 포함합니다:

모듈은 Python 정의와 선언을 포함하는 파일입니다. 파일 이름은 모듈 이름에 :file:`.py` 접미사를 더한 것입니다. 모듈

블록의 모듈 이름(문자열)은 전역 변수 ``__name__``에서 얻을 수 있습니다. 예를 들어,

선호하는 파일 편집기를 사용하여 현재 디렉터리에 :file:`fibo.py`라는 파일을 만들고 다음

내용::

# 피보나치 수 모듈

def fib(n): # 최대 n까지 피보나치 수열을 작성합니다

a, b = 0, 1

while b <

                                                                                                     >

a, b = b, a+b

결과 반환

이제 Python 인터프리터에 들어가서 다음

명령을 사용하여 이 모듈을 가져옵니다.

이제 Python 인터프리터를 입력하고 다음 명령을 사용하여 이 모듈을 가져옵니다.:

>>> import fibo

이것은 ``에 정의된 함수의 이름을 입력하지 않습니다. fibo``는 현재 기호 테이블에 직접 입력되며,

모듈 이름을 사용하여 다음 함수에 액세스할 수 있습니다.

그렇게 하면 `fibo`에 ` 함수를 직접 넣지 않고 현재 의미 테이블을 가져옵니다. 단순히 모듈 이름

``fibo``를 가져옵니다. 다음과 같이 모듈 이름을 통해 이 함수에 액세스할 수 있습니다::

>>> fibo.fib(1000)

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

>>> fibo.fib2(100)

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

>>> fibo.__name__

'fibo'

함수를 자주 사용하려는 경우 로컬 이름을 지정할 수 있습니다.

함수를 직접 호출하려면 일반적으로 로컬 이름을 지정할 수 있습니다.:

>>> fib = fibo.fib

>>> ; fib(500)

1 1 2 3 5 8 13 21 34 55 89 144 233 377

.. _tut-moremodules:

모듈 심층 모듈에 대해 자세히 알아보기

=============================

모듈에는 실행 가능한 명령문과 함수 정의가 포함될 수 있습니다. .

이 명령문은 모듈을 초기화하기 위한 것입니다.

모듈을 어딘가에 *처음* 가져올 때만 실행됩니다. 함수 정의에는 실행 문도 포함되어 있습니다. 이러한 문은 일반적으로 모듈을 초기화하는 데 사용됩니다. 모듈을 *처음* 가져올 때

한 번만 실행됩니다. [#]_

각 모듈에는 모듈에 정의된 모든 함수에 의해 전역 기호

테이블로 사용되는 자체 전용 기호 테이블이 있습니다. 🎜>

우발적인 충돌에 대한 걱정 없이 모듈의 전역 변수를 사용하세요

반면에, 자신이 무엇을 하고 있는지 알고 있다면

해당 함수를 참조하는 데 사용되는 것과 동일한 표기법을 사용하는 모듈의 전역 변수인 ``modname.itemname``.

은 각 모듈의 모든 함수를 정의하는 전역 의미 테이블에 해당합니다. 자신의 개인 의미 테이블을 가지고 있습니다. 따라서

따라서 모듈 작성자는 사용자의 전역 변수와의 충돌로 인한 오류

없이 모듈의 일부 전역 변수를 사용할 수 있습니다. 반면에 이것이 꼭 필요하다고 확신한다면 모듈의 함수를 참조하는 것처럼 모듈의 전역 변수에 다음과 같이 액세스할 수 있습니다: ``modname.itemname``.

모듈은 다른 모듈을 가져올 수 있습니다. 관례이지만 모든

:keyword:`import` 문을 모듈(또는 스크립트)의 시작 부분에 배치할 필요는 없습니다.

문제) 가져온 모듈 이름은 가져오는 모듈의 전역

기호 테이블에 배치됩니다.

모듈은 다른 모듈을 가져올 수 있습니다( :keyword:`import` ). 모든 import 문을 모듈(또는

스크립트 등) 시작 부분에 배치하는 것이 일반적이지만 필수는 아닙니다. 가져온 모듈 이름은 이 모듈의 전역 구문

에 입력됩니다.

모듈에서 이름을 가져오는 모듈의 기호 테이블로 직접 가져오는 :keyword:`import` 문의 변형이 있습니다. 예:

:keyword :`import` 문의 변형은 가져온 모듈에서 모듈의 의미 테이블로 직접 이름을 가져옵니다.

예:

>>> from fibo import fib2

>>> fib(500)

1 1 2 3 5 8 13 21 34 55 89 144 233 377

이것은

로컬 기호 테이블에서 가져오기를 가져온 모듈 이름을 소개하지 않습니다(따라서 예에서는 ``fibo``는 정의되지 않았습니다).

이것은 로컬 의미 테이블에서 모듈 이름을 가져오지 않습니다(위에 표시된 것처럼 `fibo``는 정의되지 않습니다).

모듈이 정의하는 모든 이름을 가져오는 변형도 있습니다:

from fibo import *

>>>

1 1 2 3 5 8 13 21 34 55 89 144 233 377

밑줄(``_``)로 시작하는 이름을 제외한 모든 이름을 가져옵니다.

이렇게 하면 가져옵니다. 밑줄(``_``)로 시작하는 이름을 제외한 모든 이름.

일반적으로 모듈이나 패키지에서 ``*``를 가져오는 방식은

코드 읽기가 좋지 않기 때문에 눈살을 찌푸리게 됩니다. >

이를 사용하여 대화형 세션에서 입력을 절약하세요.

실제로는 모듈이나 패키지에서 모두 가져오기 위해 ``*``를 사용하지 않는 것이 좋습니다. 왜냐하면

이렇게 하면 코드를 읽기가 어려워집니다. 그러나 대화형 세션에서 사용하는 것은 편리하고 쉽습니다.

.. 참고::

.. [#] 효율성을 위해 각 모듈은 인터프리터

세션당 한 번만 가져옵니다. 따라서 모듈을 변경하는 경우

인터프리터를 다시 시작해야 합니다. 또는 대화형으로 테스트하려는 단일 모듈인 경우

:func:`reload`를 사용합니다(예: ``reload(modulename)``).

.. [#] 성능상의 이유로 각 모듈은 통역사 세션당 한 번만 가져옵니다. 따라서 모듈을

수정하는 경우 인터프리터를 다시 시작해야 합니다. 또는 해당 모듈을 대화식으로 테스트하려는 경우 ``reload와 같은 :func:` reload` Reload를 사용할 수 있습니다. (모듈 이름)``.

.. _tut-modulesasscripts:

모듈을 스크립트로 실행

--- ------ ---------------

다음을 사용하여 Python 모듈을 실행할 때:

다음을 사용하세요. Python 모듈을 실행하는 다음 방법::

python fibo.py

모듈의 코드는 마치 가져온 것처럼 실행되지만

``__name__``을 ``"__main__"``으로 설정합니다. 즉,

모듈의 끝 부분에 이 코드를 추가하면

코드는 다음과 같습니다. 가져온 것처럼 실행되었지만 이제 ``__name__``은

``"__main__"``으로 설정되었습니다. 이는 모듈 뒤에 다음 코드를 추가하는 것과 동일합니다::

if __name__ == "__main__":

import sys

fib(int(sys.argv[1]))

파일을 가져오기 가능한 모듈뿐만 아니라 스크립트로도 사용할 수 있게 만들 수 있습니다.

명령줄을 구문 분석하는 코드는 모듈이

"기본" 파일로 실행되는 경우에만 실행되기 때문입니다.

이 파일을 기준 치수. 이 코드는 모듈이

"기본" 파일로 실행될 때만 호출됩니다::

$ python fibo.py 50

1 1 2 3 5 8 13 21 34

모듈을 가져오면 코드가 실행되지 않습니다:

모듈을 가져오면 이 코드가 실행되지 않습니다::

>>> ; import fibo

>>>

이는 모듈에 편리한 사용자 인터페이스를 제공하거나

테스트 목적(모듈 실행)에 자주 사용됩니다. 스크립트가 테스트 스위트를 실행함).

이는 일반적으로 테스트를 용이하게 하기 위해 모듈에 대한 사용자 인터페이스를 제공하는 데 사용됩니다(모듈을 테스트 요구 사항을 실행하는 스크립트로 사용).

.. _tut-searchpath:

모듈 검색 경로 모듈 검색 경로

------------------- - ------------

.. index:: 트리플: 경로

언제; :mod:`spam`이라는 모듈을 가져오면 인터프리터는

현재 디렉터리에서 :file:`spam.py`라는 파일을 검색한 다음

목록에서

환경 변수 :envvar:`PYTHONPATH`로 지정된 디렉터리입니다. 이

는 쉘 변수 :envvar:`PATH`와 동일한 구문, 즉

디렉터리 이름 목록을 갖습니다. :envvar:`PYTHONPATH`가 설정되지 않았거나

여기에서 파일을 찾을 수 없으면

Unix의 설치 종속 기본 경로에서 검색이 계속됩니다. file:`.:/usr/local/lib/python`.

:mod:`spam`이라는 모듈을 가져올 때 통역사는 먼저 현재 디렉터리에서

을 검색합니다. :file:`spam.py` 파일을 검색한 다음 환경 변수:envvar:`PYTHONPATH`로 표시되는

디렉터리 목록에서 검색한 다음 환경 변수:envvar:`PATH에서 경로 목록을 검색합니다. `.

:envvar:`PYTHONPATH`가 설정되지 않았거나 파일을 찾을 수 없는 경우 설치 디렉터리인

Unix에서는 일반적으로:file:`.:/usr을 검색하세요. /local/lib/python` .

실제로 모듈은 입력 스크립트가 포함된 디렉터리에서 초기화되는

``sys.path`` 변수에 의해 지정된 디렉터리 목록에서 검색됩니다

( 또는 현재 디렉터리), :envvar:`PYTHONPATH` 및 설치에 따른

기본값. 이를 통해 Python 프로그램은 자신이 수행 중인 작업을 알고 모듈 검색 경로를 수정하거나

바꿀 수 있습니다. . 실행 중인

스크립트가 포함된 디렉터리가 검색 경로에 있기 때문에 스크립트에 표준 모듈과 동일한 이름이 없는 것이

중요합니다. 그렇지 않으면 Python이 다음을 시도합니다. 해당 모듈을 가져올 때

스크립트를 모듈로 로드하세요. 이는 일반적으로 오류입니다. 자세한 내용은

섹션 :ref:`tut-standardmodules`를 참조하세요.

실제로 인터프리터는 ``sys.path`` 변수로 지정된 경로 디렉터리에서 모듈을 검색합니다. 여기에는 초기화될 때 기본적으로 입력 스크립트(또는 현재 디렉터리)가 포함되어 있습니다.

, :envvar: `PYTHONPATH` 및 설치 디렉터리.

이를 통해 Python 프로그램은 모듈 검색 디렉터리를 수정하거나 바꾸는 방법을 알 수 있습니다.

이 디렉토리에는 검색 경로에서 실행되는 스크립트가 포함되어 있기 때문에 이러한 스크립트는 표준 모듈과 동일한

이름을 가져서는 안 됩니다. 그렇지 않으면 Python이 이를 대체하려고 시도합니다. 모듈을 가져올 때 스크립트는 모듈로 로드됩니다. 이로 인해 일반적으로

오류가 발생합니다. 자세한 내용은 :ref:`tut-standardmodules`를 참조하세요.

"컴파일된" Python 파일 "컴파일된" Python 파일

--------------- -- -----------

많이 사용하는 짧은 프로그램의 시작 시간을 단축하는 중요한 요소로

표준 모듈의 경우, :file:`spam.pyc`라는 파일이

:file:`spam.py`가 있는 디렉토리에 존재하면

이미 "바이트 컴파일된" 모듈 버전:mod:`spam`. :file:`spam.py` 버전의 수정 시간

:file: `spam.pyc`은

:file:`spam.pyc`에 기록되며, 일치하지 않으면 :file:`.pyc` 파일은 무시됩니다.

간단히 말하면 다수의 표준 모듈을 참조하는 프로그램의 경우,

:file:`spam.py` 디렉토리에 :file:`spam이라는 파일이 있는 경우 시작 속도를 높이는 중요한 방법이 있습니다. pyc` 파일이 있으면

:mod:`spam` 모듈의 사전 "바이트 컴파일"(바이트 컴파일)

버전으로 처리됩니다. :file:`spam.pyc`를 생성하는 데 사용된 :file:`spam.py` 버전의 수정 시간은 :file:`spam.pyc` 파일에 기록됩니다. `.pyc` 파일이 일치하면 해당 파일은

무시됩니다.

일반적으로 :file:`spam.pyc` 파일을 생성하기 위해 아무 것도 할 필요가 없습니다.

:file:`spam.py`가 성공적으로 컴파일될 때마다 다음 시도가 발생합니다. 쓰도록 되어있습니다

:file:`spam.pyc`에 컴파일된 버전입니다.

어떤 이유로든 파일이 완전히 작성되지 않으면 오류가 아닙니다.

:file:`spam.pyc` 파일은 유효하지 않은 것으로 인식되어 나중에 무시됩니다.

:file:`spam.pyc` 파일의 내용은 플랫폼 독립적이므로 Python

모듈 디렉토리는 다양한 아키텍처의 시스템에서 공유될 수 있습니다.

일반적으로 :file:`spam.pyc` 파일을 생성하기 위해 어떤 작업도 수행할 필요가 없습니다. :file:`spam.py`가 성공적으로 컴파일되면

은 :file:`spam.pyc`의 해당 버전을 생성하려고 시도합니다. 어떤 이유로든 쓰기가 실패하면

에 의해 생성된 :file:`spam.pyc` 파일은 유효하지 않은 것으로 간주되어 무시됩니다. :file:`spam.pyc` 파일의 내용은 플랫폼 독립적이므로 Python 모듈 디렉토리는 다른 아키텍처의 시스템 간에 공유될 수 있습니다.

전문가를 위한 팁:

고급 팁:

* Python 인터프리터가 :option:`-O` 플래그와 함께 호출되면 최적화됩니다

코드는 :file:`.pyo` 파일에 저장됩니다. 현재

:keyword:`assert` 문만 제거합니다. :option:`-O`가 사용되며 *all* :term:`bytecode`가 최적화됩니다. ``.pyc`` 파일은

무시되고 ``.py`` 파일은 최적화된 바이트코드로 컴파일됩니다. .

:option:`-O` 매개변수를 사용하여 Python 인터프리터를 호출하면 최적화된 코드가 생성되어 :file:`.pyo` 파일에 저장됩니다.

현재 최적화 프로그램은 별로 도움이 되지 않습니다. 단언문( :keyword:`assert` )만 제거합니다. :option:`-O` 매개변수를 사용하면 *모든* 바이트코드( :term:`bytecode` )가 최적화됩니다.

무시됩니다. 최적화된 코드로 컴파일되었습니다.

* 두 개의 :option:`-O` 플래그를 Python 인터프리터(:option:`-OO`)에 전달하면

바이트코드 컴파일러가 드물게 수행할 수 있는 최적화를 수행하게 됩니다

경우에는 프로그램 오작동이 발생합니다. 현재 바이트코드에서 ``__doc__`` 문자열만

제거되어

일부 프로그램에서는 이러한 사용 가능 여부에 의존할 수 있으므로 수행 중인 작업을 알고 있는 경우에만 이

옵션을 사용해야 합니다.

Python 인터프리터에 two:option:`-O를 전달합니다. ` 인수( :option:`-OO` )는 완전히

최적화된 바이너리 컴파일을 수행하며, 이로 인해 때때로 잘못된 프로그램이 생성될 수 있습니다. 현재 최적화 프로그램은

섹션 코드에서 ``__doc__`` 문자열만 제거하여 보다 컴팩트한 :file:`.pyo` 파일을 생성합니다.

일부 프로그램은 이러한 변수의 가용성에 의존하기 때문에 확실할 경우에만 이 옵션을 사용해야 합니다.

* :file:`.pyc` 또는

:file:`.pyo` 파일에서 읽을 때보다 프로그램이 더 빠르게 실행되지는 않습니다. :file:`.py` 파일;

:file:`.pyc` 또는 :file:`.pyo` 파일에서 더 빠른 유일한 점은

로드되었습니다.

:file:`.pyc` 파일 또는 :file:`.pyo` 파일의 프로그램은

:file:`의 프로그램보다 더 빠르게 실행되지 않습니다. .py` 파일 속도가 빠릅니다. :file:`.pyc` 또는 :file:`.pyo` 파일은 로드할 때

더 빠릅니다.

* 명령줄에 이름을 지정하여 스크립트를 실행하면

스크립트의 바이트 코드가 :file:`.pyc` 또는 :file:`에 기록되지 않습니다. pyo` 파일입니다. 따라서

대부분의 코드를 모듈로 이동하고

해당 모듈을 가져오는 작은 부트스트랩 스크립트를 사용하면 스크립트 시작 시간을 줄일 수 있습니다.

:file:`.pyc` 또는 :file:`.pyo` 파일의 이름을 명령줄에서 직접 지정할 수 있습니다

스크립트를 실행할 때 스크립트에 대해 생성된 바이너리 코드입니다. :file:`.pyc` 또는 :file:`.pyo` 파일에 기록되지 않습니다. 물론 스크립트의 메인 코드를 모듈

블록으로 옮긴 다음 작은 시작 스크립트와 함께 이 모듈을 가져오면 스크립트의 시작 속도를 향상시킬 수 있습니다.

명령줄에서 :file:`.pyc` 또는 :file:`.pyo` 파일을 직접 지정할 수도 있습니다.

* :file:`spam.pyc`(또는 :option:`-O`를 사용하는 경우 :file:`spam.pyo`

)이라는 파일이 있을 수 있습니다. 동일한 모듈에 대한 :file:`spam.py` 파일이 없습니다.

이것은 리버스 엔지니어링하기 다소 어려운

형태로 Python 코드 라이브러리를 배포하는 데 사용할 수 있습니다.

동일한 모듈(여기서는 루틴:file:`spam.py` - 번역기를 참조함)에 대해

have:file:`spam.pyc` 파일(또는: file:`spam.pyc`,

:option:`-O` 매개변수를 사용할 때) :file:`spam.py` 파일이 없습니다. 이렇게 하면 패키징하여 게시할 수 있습니다

리버스 엔지니어링이 어려운 Python 코드 베이스입니다.

.. index:: module: compileall

* :mod:`compileall` 모듈은 :file:`.pyc` 파일(또는 :file:`.pyo`:option:`-O`를 사용할 경우

파일) 디렉터리의 모든 모듈에 대해.

:mod:`compileall` 모듈은 지정된 디렉터리의 모든 모듈에 대해 :file:`을 생성할 수 있습니다. .pyc` 파일

(또는 :file:`.pyo` 매개변수를 사용하여 :file:`.pyo` 파일 생성)

.. _tut-standardmodules:

표준 모듈 표준 모듈

===================== ==========

.. index:: module: sys

Python은 별도의

문서에 설명된 표준 모듈 라이브러리와 함께 제공됩니다. , Python 라이브러리 참조(이하 "라이브러리 참조"). 일부

모듈은 인터프리터에 내장되어 있습니다. 이러한 모듈은

언어의 핵심 부분은 아니지만 그럼에도 불구하고

효율성을 위해 또는

시스템 호출과 같은 운영 체제 기본 요소에 대한 액세스를 제공하기 위해 이러한 모듈 세트는

에 따라 달라지는 구성 옵션입니다. 예를 들어, :mod:`winreg` 모듈은

Windows 시스템에서만 제공됩니다. 특정 모듈 중 하나는 주의를 기울여야 합니다:

:mod:`sys` 모든 Python 인터프리터에 내장되어 있습니다.

``sys.ps1`` 및 ``sys.ps2`` 변수는 기본 및 보조

프롬프트로 사용되는 문자열을 정의합니다.

Python은 표준 모듈 라이브러리와 함께 제공되며 Python 라이브러리 참조 매뉴얼

(이하 "라이브러리 참조 매뉴얼")이라는 독립 문서를 출판합니다. 인터프리터에는 일부 모듈이 내장되어 있습니다. 이러한 작업을 위한 액세스 인터페이스는 언어 핵심의 일부가 아니지만 이미 인터프리터에 내장되어 있습니다. 이는 효율성을 향상시킬 뿐만 아니라, 시스템 호출 등 운영체제에 대한 네이티브 접근을 위한 인터페이스를 제공하기 위한 것이기도 합니다. 이러한 유형의 모듈 컬렉션은 기본 플랫폼에 따라 달라지는

구성 옵션입니다. 예를 들어 :mod:`winreg` 모듈은 Windows 시스템

에서만 사용할 수 있습니다. 주목할 만한 특정 모듈이 있습니다: :mod:`sys`, 이 모듈은 모든

Python 인터프리터에 내장되어 있습니다. sys.ps1 및 sys.ps2 변수는 기본 프롬프트 및 보조 프롬프트 문자열을 정의합니다::

>>> import sys

>>> >

'>>> '

>>> sys.ps2

'...'

>>> sys.ps1 = 'C> '

C> print '으악!'

으악!

C>

이 두 변수는 다음과 같은 경우에만 정의됩니다. 인터프리터가 대화형 모드에 있습니다.

이 두 변수는 인터프리터의 대화형 모드에서만 의미가 있습니다.

``sys.path``변수는 인터프리터의

모듈 검색 경로를 결정하는 문자열 목록입니다.

환경 변수 :envvar:`PYTHONPATH` 또는

:envvar:`PYTHONPATH`가 설정되지 않은 경우 내장 기본값에서 표준 목록

작업을 사용하여 수정할 수 있습니다.

``sys.path``변수는 인터프리터 모듈 검색 경로에 대한 문자열 목록입니다. 환경 변수

:envvar:`PYTHONPATH`에 의해 초기화됩니다. :envvar:`PYTHONPATH`가 설정되지 않은 경우 내장된 기본값

에 의해 초기화됩니다. 표준 문자열 작업을 사용하여 수정할 수 있습니다::

>>> import sys

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

.. _tut-dir:

:func:`dir` 함수 :func:`dir` 함수

====== == =============================================

내장 함수:func:`dir`은 모듈이 정의하는 이름을 찾는 데 사용됩니다

정렬된 문자열 목록을 반환합니다.

내장 함수:func :`dir`은 모듈 이름으로 모듈 정의를 검색하는 데 사용됩니다.

table::

>>> import fibo, sys

>>> dir(fibo)

['__name__', 'fib', 'fib2']

>>> dir(sys)

['__displayhook__', '__doc__', '__Exceptionhook__', '__name__', '__stderr__',

'__stdin__', '__stdout__', '_getframe', 'api_version', 'argv' ,

'builtin_module_names', 'byteorder', 'callstats', 'copyright',

'displayhook', 'exc_clear', 'exc_info', 'exc_type', '예외',

'exec_prefix', 'executable', 'exit', 'getdefaultencoding', 'getdlopenflags',

'getrecursionlimit', 'getrefcount', 'hexversion', 'maxint', 'maxunicode' ,

'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache',

'플랫폼', 'prefix', 'ps1', 'ps2', 'setcheckinterval', ' setdlopenflags',

'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout',

'version', 'version_info', 'warnoptions' ]

인수 없이 :func:`dir`은 현재 정의한 이름을 나열합니다.

매개 변수 없이 호출하면 :func:`dir` 함수는 현재 정의된 이름을 반환합니다.

>>> a = [1, 2, 3, 4, 5]

>>> ; fib = fibo.fib

>>> dir()

['__builtins__', '__doc__', '__file__', '__name__', 'a', 'fib ' , 'fibo', 'sys']

변수, 모듈, 함수 등 모든 유형의 이름을 나열합니다.

모든 유형의 이름을 나열합니다: 변수, 모듈, 기능 등

.. index:: module: __builtin__

:func:`dir`은 내장 함수 및 변수의 이름을 나열하지 않습니다.

목록을 원하는 경우 그 중 표준 모듈에 정의되어 있습니다.

:mod:`__builtin__`:

:func:`dir`에는 내장 함수 및 변수 이름이 나열되지 않습니다. 이를 나열하려면 표준 모듈

:mod:`__builtin__`::

>>> import __builtin__

> >> dir(__builtin__)

['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning',

'EOFError', 'Ellipsis', 'EnvironmentError', ' Exception', 'False',

'FloatingPointError', 'FutureWarning', 'IOError', 'ImportError',

'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt' ,

'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented',

'NotImplementedError', 'OSError', 'OverflowError',

'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError',

'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError',

'SyntaxWarning', 'SystemError', ' SystemExit', 'TabError', 'True',

'TypeError', 'UnboundLocalError', 'UnicodeDecodeError',

'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError',

'UserWarning', 'ValueError', 'Warning', 'WindowsError',

'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__',

'__name__', 'abs', 'apply', 'basestring', 'bool', 'buffer',

'callable', 'chr', 'classmethod', 'cmp', 'coerce' , '컴파일',

'복잡함', '저작권', '크레딧', 'delattr', 'dict', 'dir', 'divmod',

'열거', ' eval', 'execfile', 'exit', 'file', 'filter', 'float',

'frozenset', 'getattr', 'globals', 'hasattr', 'hash', ' help', 'hex',

'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter',

'len' , 'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview',

'min', 'object', 'oct', 'open' , 'ord', 'pow', 'property', 'quit', 'range',

'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round' , 'set',

'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super',

'tuple', ' type', 'unicr', 'unicode', 'vars', 'xrange', 'zip']

.. _tut-packages:

패키지 패키지

=============

패키지는 "점으로 구분된

모듈 이름"을 사용하여 Python의 모듈 네임스페이스를 구성하는 방법입니다. 모듈 이름 :mod:`A.B`는 ``A``라는 패키지에 ``B``라는 하위 모듈

을 지정합니다. 마치 모듈을 사용하여

다른 작성자를 저장하는 것과 같습니다. 모듈은 서로의 전역

변수 이름에 대해 걱정할 필요가 없습니다. 점으로 구분된 모듈 이름을 사용하면 NumPy 또는 Python Imaging Library와 같은 다중 모듈

패키지 작성자가 걱정할 필요가 없습니다.

서로의 모듈 이름.

패키지는 일반적으로 "점 모듈 이름"을 사용하여 구조화된 모듈 네임스페이스를 사용합니다. 예를 들어,

:mod:`A.B`라는 모듈은 ``B``라는 패키지에 있는 ``A``라는 하위 모듈을 나타냅니다.

모듈을 사용하여 다양한 모듈 아키텍처를 저장하면 전역 변수 간의 충돌을 방지하는 것과 마찬가지로 점 모듈 이름

을 사용하여 NumPy 또는 Python Imaging Library와 같은 다양한 라이브러리를 저장할 수 있습니다.

.

사운드 파일과 사운드 데이터를 처리하는 유니폼

을 위한 모듈 모음("패키지")을 디자인한다고 가정해 보겠습니다.

형식(일반적으로 확장자로 인식됩니다(예: :file:`.wav`,

:file:`.aiff`, :file:`.au`). 따라서 생성하고 유지 관리해야 할 수도 있습니다. 다양한 파일 형식 간의 변환을 위한 모듈 컬렉션이 점점 늘어나고 있습니다

사운드 데이터에 대해 수행할 수 있는 다양한 작업도 있습니다

(예: 믹싱 , 에코 추가, 이퀄라이저 기능 적용,

인공 스테레오 효과 생성), 추가로 이러한 작업을 수행하기 위해 끝없는

모듈 스트림을 작성하게 됩니다.

패키지 구조(계층적 파일 시스템으로 표현됨):

이제 사운드 파일과 사운드 데이터를 균일하게 처리하기 위해 모듈 세트("패키지")를 디자인한다고 가정해 보겠습니다.

다양한 사운드 형식이 존재합니다(종종 확장자로 식별됩니다. 예: :file:`.wav`

, :file:`.aiff`, :file: `.au` ), 따라서

다양한 유형의 파일 형식 간에 변환하려면 점점 늘어나는 패키지 컬렉션을 유지해야 합니다. 어쩌면 사운드 데이터에 대해 다양한

작업(예: 믹싱, 에코 추가, 밸런스 기능 적용, 인공 효과 생성)을 수행하고 싶기 때문에

참여하고 싶을 수도 있습니다. 이러한 작업을 수행하는 무한 스트림 모듈. 패키지는 다음과 같습니다(계층적 파일 시스템으로 그룹화)::

sound/ the Sound Package

Formats/ Subpackage for File Format Conversions

__init __.

wavread.py

wavwrite.py

aifread. >>                                                … 필터/ 필터용 하위 패키지

__init__. py

equalizer.py

vo coder.py

karaoke.py

패키지를 가져올 때 Python은 다음을 통해 검색합니다.

``sys.path``에 있는 디렉터리는 패키지 하위 디렉터리를 찾습니다.

모듈을 가져올 때 Python은 ``sys.path의 디렉터리 목록``을 통해 패키지가 있는 하위 디렉터리를 검색합니다. 저장됩니다.

Python이 디렉터리를 처리하도록 하려면 :file:`__init__.py` 파일이 필요합니다

패키지를 포함하므로, 이는

``string``과 같은 일반 이름을 가진 디렉터리가 나중에 모듈 검색에서 나타나는 유효한 모듈을 의도치 않게 숨기는 것을 방지하기 위해 수행됩니다

가장 간단한 경우, :file:`__init__.py`는

빈 파일일 수도 있지만, 패키지에 대한 초기화 코드를 실행하거나

``__all__을 설정할 수도 있습니다. `` 변수, 나중에 설명합니다.

Python이 디렉터리를

패키지로 처리하려면 :file:`__init__.py` 파일이 있어야 합니다. 이는 특정 Some을 방지하기 위한 것입니다. 디렉터리는 ``string``과 같은 일반 이름을 사용하고

뒤에 오는 모듈 검색 경로에서 실수로 올바른 모듈을 덮어씁니다. 가장 간단한 경우

:file:`__init__.py`는 빈 파일일 수도 있지만 패키지 초기화 코드를 포함하거나 나중에 따라야 할 ``__all__`` 변수를 설정할 수도 있습니다. 관련 소개.

패키지 사용자는 패키지에서 개별 모듈을 가져올 수 있습니다.

예:

패키지 사용자는 패키지에서 개별 모듈을 가져올 수 있습니다.

import sound. Effects.echo

이것은 하위 모듈 :mod:`sound.효과.echo`를 로드합니다.

전체 이름을 참조해야 합니다. >

이런 방식으로 :mod:`Sound.Effects.echo` 하위 모듈을 가져옵니다. 전체 이름으로 참조되어야 합니다. ::

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

하위 모듈을 가져오는 다른 방법은 다음과 같습니다:

import 다음을 패키징하는 선택적 방법이 있습니다::

from sound. Effects import echo

이것은 또한 하위 모듈 :mod:`echo`를 로드하고

패키지 접두사이므로 다음과 같이 사용할 수 있습니다.

이렇게 하면 :mod:`echo` 하위 모듈이 로드되어 패키지 접두사

없이 사용할 수 있게 되므로 다음과 같이 호출할 수 있습니다. 다음::

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

또 다른 변형은 원하는 함수나 변수를 직접 가져오는 것입니다.

함수나 변수를 직접 가져오는 또 다른 변형이 있습니다:

from sound.effs.echo import echofilter

다시 말하면, 이는 하위 모듈 mod:`echo`를 로드하지만 이는 해당 기능을 수행하게 합니다.

:func:`echofilter` 직접 사용 가능:

이것은 :mod:`echo` 하위 모듈을 다시 로드하지만 이로 인해

:func를 호출할 수 있습니다. `echofilter` 함수 직접::

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

``from package import item``을 사용할 때 항목은 다음과 같을 수 있습니다.

패키지의 하위 모듈(또는 하위 패키지) 또는

패키지에 정의된 다른 이름(예: 함수, 클래스 또는 변수) ``import`` 문이 먼저

항목이 패키지에 정의되어 있는지 테스트합니다. 그렇지 않으면

모듈이라고 가정하고 로드를 시도합니다. 항목을 찾지 못하면 :exc:`ImportError`

예외가 발생했습니다.

``from package import item``을 사용하여 패키지를 가져올 때 이 하위 항목( 항목)은 하위 모듈(또는 하위 패키지) 또는 함수, 클래스, 변수 등 패키지에 정의된 다른 이름입니다. import 문은 먼저 패키지에 하위 키가 있는지 확인하고, 그렇지 않은 경우 이것이 모듈이라고 가정하고 로드를 시도합니다. 찾지 못하면 ImportError 예외가 발생합니다.

반대로 ``import item.subitem.subsubitem``과 같은 구문을 사용하는 경우

마지막 항목을 제외한 각 항목은 패키지여야 합니다. 🎜>

패키지는 이전

항목에 정의된 클래스, 함수 또는 변수일 수 없습니다.

대신 ``import item.subitem.subsubitem``과 같은 것을 사용하세요. 구문을 사용할 때 이러한 하위 항목은

패키지여야 합니다. 마지막 하위 항목은 패키지나 모듈일 수 있지만 클래스, 함수 또는 변수

일 수는 없습니다. 이전 하위 항목.

.. _tut-pkg-import-star:

패키지에서 /* 가져오기

---------------- -----------

.. index:: Single: __all__

이제 사용자가 ``from sound.effics import *``라고 쓰면 어떻게 될까요? ,

이것이 어떻게든 파일 시스템으로 나가서

패키지에 있는 하위 모듈을 찾아 모두 가져오길 바랍니다.

오랜 시간이 걸릴 수 있습니다. 시간 및 하위 모듈 가져오기에는 하위 모듈을 명시적으로 가져올 때만 발생해야 하는 원하지 않는 부작용이 있을 수 있습니다. 이상적으로는 파일 시스템에서 패키지의 모든 하위 모듈을 찾아 가져오는 것이 좋습니다.

시간이 오래 걸릴 수 있고 예상치 못한 가장자리 효과가 있을 수 있습니다. 원하는 패키지를 내보내는 것은 명시적으로만 가져올 수 있습니다.

유일한 해결책은 패키지 작성자가

패키지의 명시적인 색인을 제공하는 것입니다. :keyword:`import` 문은 다음 규칙을 사용합니다. >:file:`__init__.py` 코드는 ``__all__``이라는 이름의 목록을 정의하며,

``from package import *``가 실행될 때 가져와야 하는 모듈 이름 목록으로 간주됩니다.

패키지의 새 버전이 출시될 때 이 목록을 최신 상태로 유지하는 것은 패키지 작성자의 몫입니다

패키지에서 /*를 가져오는 용도가 없다면 지원하세요.

예를 들어, :file:`sounds/ Effects/__init__.py` 파일에는 다음이 포함될 수 있습니다

code:

패키지 작성자를 위한 유일한 솔루션은 명시적인 패키지 색인을 제공하는 것입니다.

:keyword:`import` 문은 다음 조건에 따라 변환됩니다. ``from package import

*``를 실행할 때 :file:`__init__.py` 코드 정의가 있는 경우 패키지에서 ``__all__``

이라는 이름의 목록은 목록에 제공된 모듈 이름에 따라 가져옵니다. 작성자는 패키지의 새 버전이 출시되면

이 목록을 마음대로 업데이트할 수 있습니다. 패키지 작성자가 *,

을 가져올 때 패키지의 모든 모듈을 가져오지 않으려는 경우 이를 지원하지 않기로 결정할 수 있습니다(가져오기 /*). 예:

:file:`Sounds/Effects/__init__.py` 이 파일에는 다음 코드가 포함될 수 있습니다::

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

이는 ``from sound.효과 import *``가

:mod:`sound` 패키지의 명명된 하위 모듈 3개를 가져오는 것을 의미합니다.

이것은 ``from Sound.Effects import *`` 문은 :mod:`sound` 패키지에서 위의 세 가지 이름이 지정된 하위 모듈을 가져옵니다.

``__all__``이 정의되지 않은 경우 ``from sound. effects import *``

문은 :mod:`sound 패키지에서 모든 하위 모듈을 가져오지 *않습니다*. 효과`를

현재 네임스페이스에 추가합니다. 이는 :mod:`sound.효과` 패키지가

가져왔는지 확인합니다(아마도 :file:`__init__.py에서 초기화 코드를 실행할 수 있음). `)

그리고 패키지에 정의된 모든 이름을 가져옵니다. 여기에는 :file:`__init__.py`에 의해 정의된 모든

이름(및 명시적으로 로드된 하위 모듈)이 포함됩니다.

이전 :keyword:`import` 문에 의해 명시적으로 로드된 패키지의 하위 모듈도 포함됩니다.

``__all__``이 정의되지 않은 경우, ` `from Sound.Effects import *`` 문은

:mod:`sound.효과` 패키지에서 모든 하위 모듈을 가져오지 않습니다. 패키지에 정의된 이름이 몇 개이든 관계없이 :mod:`sound. Effects` 패키지를 가져왔는지만 확인할 수 있습니다(__init__.py의 초기화 코드가 실행될 수 있음). 그리고 패키지에 정의된 모든 이름은 수입. 이는 __init__.py

에서 모든 명명된(그리고 명시적으로 가져온 하위 모듈)을 가져옵니다. 또한 앞서 언급한

:keyword:`import` 문을 통해 패키지에서 명시적으로 가져온 하위 모듈도 포함됩니다. 다음 코드를 고려하세요::

import sound. Effects.echo

import sound.effs.surround

from sound.효과 import *

이 예에서는 :mod:`echo` 및 :mod:`surround` 모듈을

``from...import`` 문이 실행될 때 :mod:`sound.효과` 패키지에 정의되어 있기 때문에 현재 네임스페이스입니다

(이것은 다음 경우에도 작동합니다

``__all__``이 정의되었습니다.)

이 예에서 :mod:`echo` 및 :mod:`surround` 모듈은 현재 네임스페이스

를 가져옵니다. 그 이유는 ``from...import`` 문을 실행할 때

:mod:`sound.efficents` 패키지에 이미 정의되어 있습니다(``__all__``이 정의된 경우에도 동일하게 작동합니다).

``import *``를 사용할 때 특정

패턴을 따르는 이름만 내보내도록 특정 모듈이 설계되었지만,

프로덕션 코드에서는 여전히 나쁜 습관으로 간주됩니다. .

일부 모듈은 ``import *``를 사용할 때 특정 패턴과 일치하는 이름만 내보내도록 설계되어 있지만

은 프로덕션 코드에서 사용하지 않는 것이 좋습니다.

``from Package import

special_submodule``을 사용해도 문제가 없다는 점을 기억하세요. 실제로

가져오기 모듈에서 사용해야 하는 경우가 아니면 권장되는 표기법입니다! 다른

패키지에서 같은 이름을 가진 하위 모듈.

``from Package importSpecific_submodule``에는 오류가 없다는 점을 기억하세요! 실제로

을 제외하고 가져오지 않은 모듈은 다른 패키지에서 동일한 이름을 가진 하위 모듈을 사용해야 합니다. 그렇지 않은 경우 권장되는 작성 방법입니다.

패키지 내 참조 패키지 참조

-------------------------------- - ------

하위 모듈은 종종 서로를 참조해야 합니다. 예를 들어

:mod:`surround` 모듈은 :mod:`echo` 모듈을 사용할 수 있습니다. 실제로 이러한

참조는 너무 일반적이어서 :keyword:`import` 문은 표준 모듈 검색 경로를 찾기 전에

포함 패키지를 먼저 찾습니다. >

:mod:`surround` 모듈은 단순히 ``import echo`` 또는 ``from echo import

echofilter``를 사용할 수 있습니다. 가져온 모듈이 현재 패키지(

현재 모듈이 하위 모듈인 패키지), :keyword:`import`

문은 주어진 이름을 가진 최상위 모듈을 찾습니다.

서브 모듈 종종 서로를 참조해야 합니다. 예를 들어, :mod:`surround` 모듈은

을 참조할 수 있습니다.

:mod:`echo` 모듈. 실제로 이러한 참조는 너무 일반적이어서 :keyword:`import`

문이 먼저 패키지 내부를 검색한 다음 표준 모듈 검색 경로를 검색합니다. 따라서 :mod:`surround` 모듈

블록은 간단히 ``import echo`` 또는 ``from echo import echofilter``

를 호출할 수 있습니다. 가져올 모듈이 현재 패키지에 없으면 :keyword:`import` 문은

색인에 따라 이름이 지정된 최상위 모듈을 찾습니다.

패키지가 하위 패키지로 구성된 경우(예제의 :mod:`sound` 패키지

와 같이) 절대 가져오기를 사용하여 형제 하위 모듈을 참조할 수 있습니다

:mod:`sound. Effects` 패키지의 :mod:`echo` 모듈을 사용해야 하는 경우 다음을 수행할 수 있습니다. ``from

sound. Effects import echo``를 사용하세요.

패키지에서 하위 패키지 구조를 사용하는 경우(예: :mod:`sound` 패키지), 절대 위치를 누를 수 있습니다.

는 인접한 패키지에서 하위 모듈을 가져옵니다. 예를 들어, :mod:`sound.filters.vocoder` 패키지에서

:mod:`sound.효과` 패키지의 :mod:`echo` 모듈을 사용해야 하는 경우

` `Sound.Effects에서 import echo`` .

Python 2.5부터는 위에서 설명한

암시적 상대 가져오기 외에도 ``from module import

name`` 형식을 사용하여 명시적 상대 가져오기를 작성할 수 있습니다. 이러한 명시적 상대 가져오기는 선행

점을 사용하여 상대

가져오기와 관련된 현재 및 상위 패키지를 나타냅니다. 예를 들어 :mod:`surround` 모듈에서 다음을 수행할 수 있습니다. 사용:

Python 2.5부터 앞서 언급한 내부 명시적 상대 위치 가져오기가 개선되었습니다.

형식으로 ``from module import name``을 사용하여 명시적인 상대 위치를 작성할 수 있습니다. 수식의 위치를 ​​가져옵니다. 명시적인

가져오기 쌍은 가져온 현재 패키지와 상위 패키지를 연결하기 위해 점으로 표시됩니다. :mod:`surround` 모듈을 예로 들면 다음과 같이

을 사용할 수 있습니다::

from . import echo

from .. import format

from ..filters 가져오기 이퀄라이저

주요 모듈의 이름은 항상 ``이므로 명시적 및 암시적 상대 가져오기는 모두 현재 모듈의 이름을 기반으로 합니다.

"__main__" ``,

Python 애플리케이션의 기본 모듈로 사용하려는 모듈은

항상 절대 가져오기를 사용해야 합니다.

명시적이거나 암시적이라는 점에 유의해야 합니다. 상대 위치 가져오기는 현재 모듈의 이름을 기반으로 합니다. 메인 모듈의 이름은 항상 ``"__main__"``이기 때문에 Python 애플리케이션의 메인 모듈은 항상 절대적으로 가져와야 합니다.

여러 디렉터리의 패키지

------------------ ----- --------

패키지는 하나 이상의 특수 속성인 :attr:`__path__`를 지원합니다. 이는

초기화되었습니다. 해당 파일의 코드가 실행되기 전에

패키지의 :file:`__init__.py`를 포함하는 디렉토리 이름을 포함하는 목록이어야 합니다. 이렇게 하면

변수가 수정될 수 있습니다. 패키지에 포함된

모듈 및 하위 패키지에 대한 향후 검색에 영향을 미칩니다.

패키지는 보다 특별한 기능인 :attr:`__path__`를 지원합니다. 이 변수는 패키지의

:file:`__init__.py`

파일 코드가 실행되기 전에 디렉터리 이름 목록을 초기화합니다. 이 변수는 수정이 가능하며

패키지의 하위 패키지 및 모듈 검색 기능에 작용합니다.

이 기능은 자주 필요하지는 않지만,

패키지 세트에 있는 모듈 세트를 확장하는 데 사용할 수 있지만 일반적으로 사용되지는 않습니다.

.. 루브릭:: 각주

.. [#] 사실 함수 정의는 '실행'되는 '문장'이기도 합니다.

모듈 실행- 레벨 함수는 모듈의

전역 기호 테이블에 함수 이름을 입력합니다.

.. [#] 실제로 함수 정의는 "선언"이자 "실행 가능한 본문"입니다. 실행 가능 본문은 모듈의 전역 의미 테이블에 있는 명명된 가져오기 함수로 구성됩니다.

위 내용은 Python 2.7 기본 튜토리얼: 모듈 내용입니다. 더 많은 관련 내용은 PHP 중국어 홈페이지(www.php.cn)를 참고해주세요!