용어집
******

">>>"
   대화형 셸의 기본 파이썬 프롬프트. 인터프리터에서 대화형으로 실행될
   수 있는 코드 예에서 자주 볼 수 있다.

"..."
   The default Python prompt of the interactive shell when entering
   code for an indented code block, when within a pair of matching
   left and right delimiters (parentheses, square brackets, curly
   braces or triple quotes), or after specifying a decorator.

2to3
   파이썬 2.x 코드를 파이썬 3.x 코드로 변환하려고 시도하는 도구인데,
   소스를 파싱하고 파스 트리를 탐색해서 감지할 수 있는 대부분의 비호환
   성을 다룬다.

   2to3 는 표준 라이브러리에서 "lib2to3" 로 제공된다; 독립적으로 실행
   할 수 있는 스크립트는 "Tools/scripts/2to3" 로 제공된다. 2to3 -
   Automated Python 2 to 3 code translation 를 보세요.

abstract base class (추상 베이스 클래스)
   Abstract base classes complement *duck-typing* by providing a way
   to define interfaces when other techniques like "hasattr()" would
   be clumsy or subtly wrong (for example with magic methods).  ABCs
   introduce virtual subclasses, which are classes that don't inherit
   from a class but are still recognized by "isinstance()" and
   "issubclass()"; see the "abc" module documentation.  Python comes
   with many built-in ABCs for data structures (in the "collections"
   module), numbers (in the "numbers" module), and streams (in the
   "io" module). You can create your own ABCs with the "abc" module.

argument (인자)
   A value passed to a *function* (or *method*) when calling the
   function.  There are two types of arguments:

   * *키워드 인자 (keyword argument)*: 함수 호출 때 식별자가 앞에 붙
     은 인자 (예를 들어, "name=") 또는 "**" 를 앞에 붙인 딕셔너리로 전
     달 되는 인자. 예를 들어, 다음과 같은 "complex()" 호출에서 "3" 과
     "5" 는 모두 키워드 인자다:

        complex(real=3, imag=5)
        complex(**{'real': 3, 'imag': 5})

   * *위치 인자 (positional argument)*: 키워드 인자가 아닌 인자. 위
     치 인자들은 인자 목록의 처음에 나오거나 *이터러블* 의 앞에 "*" 를
     붙 여 전달할 수 있다. 예를 들어, 다음과 같은 호출에서 "3" 과 "5"
     는 모두 위치 인자다.

        complex(3, 5)
        complex(*(3, 5))

   인자는 함수 바의 이름 붙은 지역 변수에 대입된다. 이 대입에 적용되는
   규칙들에 대해서는 호출 섹션을 보세요. 문법적으로, 어떤 표현식이건
   인자로 사용될 수 있다; 구해진 값이 지역 변수에 대입된다.

   See also the *parameter* glossary entry and the FAQ question on the
   difference between arguments and parameters.

attribute (어트리뷰트)
   점표현식을 사용하는 이름으로 참조되는 객체와 결합한 값. 예를 들어,
   객체 *o* 가 어트리뷰트 *a* 를 가지면, *o.a* 처럼 참조된다.

BDFL
   자비로운 종신 독재자 (Benevolent Dictator For Life), 즉 Guido van
   Rossum, 파이썬의 창시자.

bytes-like object (바이트열류 객체)
   An object that supports the buffer protocol, like "str",
   "bytearray" or "memoryview". Bytes-like objects can be used for
   various operations that expect binary data, such as compression,
   saving to a binary file or sending over a socket. Some operations
   need the binary data to be mutable, in which case not all bytes-
   like objects can apply.

bytecode (바이트 코드)
   Python source code is compiled into bytecode, the internal
   representation of a Python program in the CPython interpreter.  The
   bytecode is also cached in ".pyc" and ".pyo" files so that
   executing the same file is faster the second time (recompilation
   from source to bytecode can be avoided).  This "intermediate
   language" is said to run on a *virtual machine* that executes the
   machine code corresponding to each bytecode. Do note that bytecodes
   are not expected to work between different Python virtual machines,
   nor to be stable between Python releases.

   바이트 코드 명령어들의 목록은 dis 모듈 도큐멘테이션에 나온다.

class (클래스)
   사용자 정의 객체들을 만들기 위한 주형. 클래스 정의는 보통 클래스의
   인스턴스를 대상으로 연산하는 메서드 정의들을 포함한다.

classic class
   Any class which does not inherit from "object".  See *new-style
   class*.  Classic classes have been removed in Python 3.

coercion (코어션)
   The implicit conversion of an instance of one type to another
   during an operation which involves two arguments of the same type.
   For example, "int(3.15)" converts the floating point number to the
   integer "3", but in "3+4.5", each argument is of a different type
   (one int, one float), and both must be converted to the same type
   before they can be added or it will raise a "TypeError".  Coercion
   between two operands can be performed with the "coerce" built-in
   function; thus, "3+4.5" is equivalent to calling
   "operator.add(*coerce(3, 4.5))" and results in "operator.add(3.0,
   4.5)".  Without coercion, all arguments of even compatible types
   would have to be normalized to the same value by the programmer,
   e.g., "float(3)+4.5" rather than just "3+4.5".

complex number (복소수)
   익숙한 실수 시스템의 확장인데, 모든 숫자가 실수부와 허수부의 합으로
   표현된다. 허수부는 실수에 허수 단위 ("-1" 의 제곱근)를 곱한 것인데,
   종종 수학에서는 "i" 로, 공학에서는 "j" 로 표기한다. 파이썬은 후자의
   표기법을 쓰는 복소수를 기본 지원한다; 허수부는 "j" 접미사를 붙여서
   표기한다, 예를 들어, "3+1j". "math" 모듈의 복소수 버전이 필요하면,
   "cmath" 를 사용한다. 복소수의 활용은 꽤 수준 높은 수학적 기능이다.
   필요하다고 느끼지 못한다면, 거의 확실히 무시해도 좋다.

context manager (컨텍스트 관리자)
   "__enter__()" 와 "__exit__()" 메서드를 정의함으로써 "with" 문에서
   보이는 환경을 제어하는 객체. **PEP 343** 로 도입되었다.

CPython
   파이썬 프로그래밍 언어의 규범적인 구현인데, python.org 에서 배포된
   다. 이 구현을 Jython 이나 IronPython 과 같은 다른 것들과 구별할 필
   요가 있을 때 용어 "CPython" 이 사용된다.

decorator (데코레이터)
   다른 함수를 돌려주는 함수인데, 보통 "@wrapper" 문법을 사용한 함수
   변환으로 적용된다. 데코레이터의 흔한 예는 "classmethod()" 과
   "staticmethod()" 다.

   데코레이터 문법은 단지 편의 문법일 뿐이다. 다음 두 함수 정의는 의미
   상으로 동등하다:

      def f(...):
          ...
      f = staticmethod(f)

      @staticmethod
      def f(...):
          ...

   같은 개념이 클래스에도 존재하지만, 덜 자주 쓰인다. 데코레이터에 대
   한 더 자세한 내용은 함수 정의 와 클래스 정의 의 도큐멘테이션을 보면
   된다.

descriptor (디스크립터)
   Any *new-style* object which defines the methods "__get__()",
   "__set__()", or "__delete__()".  When a class attribute is a
   descriptor, its special binding behavior is triggered upon
   attribute lookup.  Normally, using *a.b* to get, set or delete an
   attribute looks up the object named *b* in the class dictionary for
   *a*, but if *b* is a descriptor, the respective descriptor method
   gets called.  Understanding descriptors is a key to a deep
   understanding of Python because they are the basis for many
   features including functions, methods, properties, class methods,
   static methods, and reference to super classes.

   디스크립터의 메서드들에 대한 자세한 내용은 디스크립터 구현하기 에
   나온다.

dictionary (딕셔너리)
   An associative array, where arbitrary keys are mapped to values.
   The keys can be any object with "__hash__()"  and "__eq__()"
   methods. Called a hash in Perl.

dictionary view (딕셔너리 뷰)
   The objects returned from "dict.viewkeys()", "dict.viewvalues()",
   and "dict.viewitems()" are called dictionary views. They provide a
   dynamic view on the dictionary’s entries, which means that when the
   dictionary changes, the view reflects these changes. To force the
   dictionary view to become a full list use "list(dictview)".  See 딕
   셔너리 뷰 객체.

docstring (독스트링)
   클래스, 함수, 모듈에서 첫 번째 표현식으로 나타나는 문자열 리터럴.
   스위트가 실행될 때는 무시되지만, 컴파일러에 의해 인지되어 둘러싼 클
   래스, 함수, 모듈의 "__doc__" 어트리뷰트로 삽입된다. 인트로스팩션을
   통해 사용할 수 있으므로, 객체의 도큐멘테이션을 위한 규범적인 장소다
   .

duck-typing (덕 타이핑)
   올바른 인터페이스를 가졌는지 판단하는데 객체의 형을 보지 않는 프로
   그래밍 스타일; 대신, 단순히 메서드나 어트리뷰트가 호출되거나 사용된
   다 ("오리처럼 보이고 오리처럼 꽥꽥댄다면, 그것은 오리다.") 특정한
   형 대신에 인터페이스를 강조함으로써, 잘 설계된 코드는 다형적인 치환
   을 허락함으로써 유연성을 개선할 수 있다. 덕 타이핑은 "type()" 이나
   "isinstance()" 을 사용한 검사를 피한다. (하지만, 덕 타이핑이 *추상
   베이스 클래스* 로 보완될 수 있음에 유의해야 한다.) 대신에,
   "hasattr()" 검사나 *EAFP* 프로그래밍을 쓴다.

EAFP
   허락보다는 용서를 구하기가 쉽다 (Easier to ask for forgiveness than
   permission). 이 흔히 볼 수 있는 파이썬 코딩 스타일은, 올바른 키나
   어트리뷰트의 존재를 가정하고, 그 가정이 틀리면 예외를 잡는다. 이 깔
   끔하고 빠른 스타일은 많은 "try" 와 "except" 문의 존재로 특징지어진
   다. 이 테크닉은 C와 같은 다른 많은 언어에서 자주 사용되는 *LBYL* 스
   타일과 대비된다.

expression (표현식)
   A piece of syntax which can be evaluated to some value.  In other
   words, an expression is an accumulation of expression elements like
   literals, names, attribute access, operators or function calls
   which all return a value.  In contrast to many other languages, not
   all language constructs are expressions.  There are also
   *statement*s which cannot be used as expressions, such as "print"
   or "if".  Assignments are also statements, not expressions.

extension module (확장 모듈)
   C 나 C++ 로 작성된 모듈인데, 파이썬의 C API를 사용해서 핵심이나 사
   용자 코드와 상호 작용한다.

file object (파일 객체)
   하부 자원에 대해 파일 지향적 API ("read()" 나 "write()" 같은 메서드
   들) 를 드러내는 객체. 만들어진 방법에 따라, 파일 객체는 실제 디스크
   상의 파일이나 다른 저장장치나 통신 장치 (예를 들어, 표준 입출력, 인
   -메모리 버퍼, 소켓, 파이프, 등등)에 대한 액세스를 중계할 수 있다.
   파일 객체는 *파일류 객체 (file-like objects)* 나 *스트림 (streams)*
   이라고도 불린다.

   There are actually three categories of file objects: raw binary
   files, buffered binary files and text files.  Their interfaces are
   defined in the "io" module.  The canonical way to create a file
   object is by using the "open()" function.

file-like object (파일류 객체)
   *파일 객체* 의 비슷한 말.

finder (파인더)
   An object that tries to find the *loader* for a module. It must
   implement a method named "find_module()". See **PEP 302** for
   details.

floor division (정수 나눗셈)
   가장 가까운 정수로 내림하는 수학적 나눗셈. 정수 나눗셈 연산자는
   "//" 다. 예를 들어, 표현식 "11 // 4" 의 값은 "2" 가 되지만, 실수 나
   눗셈은 "2.75" 를 돌려준다. "(-11) // 4" 가 "-2.75" 를 *내림* 한
   "-3" 이 됨에 유의해야 한다. **PEP 238** 를 보세요.

function (함수)
   호출자에게 어떤 값을 돌려주는 일련의 문장들. 없거나 그 이상의 *인자
   * 가 전달될 수 있는데, 바디의 실행에 사용될 수 있다. *파라미터* 와
   *메서드* 와 함수 정의 섹션도 보세요.

__future__
   A pseudo-module which programmers can use to enable new language
   features which are not compatible with the current interpreter.
   For example, the expression "11/4" currently evaluates to "2". If
   the module in which it is executed had enabled *true division* by
   executing:

      from __future__ import division

   the expression "11/4" would evaluate to "2.75".  By importing the
   "__future__" module and evaluating its variables, you can see when
   a new feature was first added to the language and when it will
   become the default:

      >>> import __future__
      >>> __future__.division
      _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

garbage collection (가비지 수거)
   The process of freeing memory when it is not used anymore.  Python
   performs garbage collection via reference counting and a cyclic
   garbage collector that is able to detect and break reference
   cycles.

generator (제너레이터)
   A function which returns an iterator.  It looks like a normal
   function except that it contains "yield" statements for producing a
   series of values usable in a for-loop or that can be retrieved one
   at a time with the "next()" function. Each "yield" temporarily
   suspends processing, remembering the location execution state
   (including local variables and pending try-statements).  When the
   generator resumes, it picks up where it left off (in contrast to
   functions which start fresh on every invocation).

generator expression (제너레이터 표현식)
   이터레이터를 돌려주는 표현식. 루프 변수와 범위를 정의하는 "for" 표
   현식과 생략 가능한 "if" 표현식이 뒤에 붙는 일반 표현식 처럼 보인다.
   결합한 표현식은 둘러싼 함수를 위한 값들을 만들어낸다:

      >>> sum(i*i for i in range(10))         # sum of squares 0, 1, 4, ... 81
      285

GIL
   *전역 인터프리터 록* 을 보세요.

global interpreter lock (전역 인터프리터 록)
   한 번에 오직 하나의 스레드가 파이썬 *바이트 코드* 를 실행하도록 보
   장하기 위해 *CPython* 인터프리터가 사용하는 메커니즘. ("dict" 와 같
   은 중요한 내장형들을 포함하는) 객체 모델이 묵시적으로 동시 액세스에
   대해 안전하도록 만들어서 CPython 구현을 단순하게 만든다. 인터프리터
   전체를 로킹하는 것은 인터프리터를 다중스레드화하기 쉽게 만드는 대신
   , 다중 프로세서 기계가 제공하는 병렬성의 많은 부분을 희생한다.

   하지만, 어떤 확장 모듈들은, 표준이나 제삼자 모두, 압축이나 해싱 같
   은 계산 집약적인 작업을 수행할 때는 GIL 을 반납하도록 설계되었다.
   또한, I/O를 할 때는 항상 GIL 을 반납한다.

   (훨씬 더 미세하게 공유 데이터를 로킹하는) "스레드에 자유로운(free-
   threaded)" 인터프리터를 만들고자 하는 과거의 노력은 성공적이지 못했
   는데, 흔한 단일 프로세서 경우의 성능 저하가 심하기 때문이다. 이 성
   능 이슈를 극복하는 것은 구현을 훨씬 복잡하게 만들어서 유지 비용이
   더 들어갈 것으로 여겨지고 있다.

hashable (해시 가능)
   An object is *hashable* if it has a hash value which never changes
   during its lifetime (it needs a "__hash__()" method), and can be
   compared to other objects (it needs an "__eq__()" or "__cmp__()"
   method). Hashable objects which compare equal must have the same
   hash value.

   해시 가능성은 객체를 딕셔너리의 키나 집합의 멤버로 사용할 수 있게
   하는데, 이 자료 구조들이 내부적으로 해시값을 사용하기 때문이다.

   All of Python's immutable built-in objects are hashable, while no
   mutable containers (such as lists or dictionaries) are.  Objects
   which are instances of user-defined classes are hashable by
   default; they all compare unequal (except with themselves), and
   their hash value is derived from their "id()".

IDLE
   파이썬을 위한 통합 개발 환경 (Integrated Development Environment).
   IDLE은 파이썬의 표준 배포판에 따라오는 기초적인 편집기와 인터프리터
   환경이다.

immutable (불변)
   고정된 값을 갖는 객체. 불변 객체는 숫자, 문자열, 튜플을 포함한다.
   이런 객체들은 변경될 수 없다. 새 값을 저장하려면 새 객체를 만들어야
   한다. 변하지 않는 해시값이 있어야 하는 곳에서 중요한 역할을 한다,
   예를 들어, 딕셔너리의 키.

integer division
   Mathematical division discarding any remainder.  For example, the
   expression "11/4" currently evaluates to "2" in contrast to the
   "2.75" returned by float division.  Also called *floor division*.
   When dividing two integers the outcome will always be another
   integer (having the floor function applied to it). However, if one
   of the operands is another numeric type (such as a "float"), the
   result will be coerced (see *coercion*) to a common type.  For
   example, an integer divided by a float will result in a float
   value, possibly with a decimal fraction.  Integer division can be
   forced by using the "//" operator instead of the "/" operator.  See
   also *__future__*.

importing (임포팅)
   한 모듈의 파이썬 코드가 다른 모듈의 파이썬 코드에서 사용될 수 있도
   록 하는 절차.

importer (임포터)
   모듈을 찾기도 하고 로드 하기도 하는 객체; 동시에 *파인더* 이자 *로
   더* 객체다.

interactive (대화형)
   파이썬은 대화형 인터프리터를 갖고 있는데, 인터프리터 프롬프트에서
   문장과 표현식을 입력할 수 있고, 즉각 실행된 결과를 볼 수 있다는 뜻
   이다. 인자 없이 단지 "python" 을 실행하라 (컴퓨터의 주메뉴에서 선택
   하는 것도 가능할 수 있다). 새 아이디어를 검사하거나 모듈과 패키지를
   들여다보는 매우 강력한 방법이다 ("help(x)" 를 기억하세요).

interpreted (인터프리티드)
   바이트 코드 컴파일러의 존재 때문에 그 구분이 흐릿해지기는 하지만,
   파이썬은 컴파일 언어가 아니라 인터프리터 언어다. 이것은 명시적으로
   실행 파일을 만들지 않고도, 소스 파일을 직접 실행할 수 있다는 뜻이다
   . 그 프로그램이 좀 더 천천히 실행되기는 하지만, 인터프리터 언어는
   보통 컴파일 언어보다 짧은 개발/디버깅 주기를 갖는다. *대화형* 도 보
   세요.

iterable (이터러블)
   An object capable of returning its members one at a time. Examples
   of iterables include all sequence types (such as "list", "str", and
   "tuple") and some non-sequence types like "dict" and "file" and
   objects of any classes you define with an "__iter__()" or
   "__getitem__()" method.  Iterables can be used in a "for" loop and
   in many other places where a sequence is needed ("zip()", "map()",
   ...).  When an iterable object is passed as an argument to the
   built-in function "iter()", it returns an iterator for the object.
   This iterator is good for one pass over the set of values.  When
   using iterables, it is usually not necessary to call "iter()" or
   deal with iterator objects yourself.  The "for" statement does that
   automatically for you, creating a temporary unnamed variable to
   hold the iterator for the duration of the loop.  See also
   *iterator*, *sequence*, and *generator*.

iterator (이터레이터)
   An object representing a stream of data.  Repeated calls to the
   iterator's "next()" method return successive items in the stream.
   When no more data are available a "StopIteration" exception is
   raised instead.  At this point, the iterator object is exhausted
   and any further calls to its "next()" method just raise
   "StopIteration" again.  Iterators are required to have an
   "__iter__()" method that returns the iterator object itself so
   every iterator is also iterable and may be used in most places
   where other iterables are accepted.  One notable exception is code
   which attempts multiple iteration passes.  A container object (such
   as a "list") produces a fresh new iterator each time you pass it to
   the "iter()" function or use it in a "for" loop.  Attempting this
   with an iterator will just return the same exhausted iterator
   object used in the previous iteration pass, making it appear like
   an empty container.

   이터레이터 형 에 더 자세한 내용이 있다.

key function (키 함수)
   키 함수 또는 콜레이션(collation) 함수는 정렬(sorting)이나 배열
   (ordering)에 사용되는 값을 돌려주는 콜러블이다. 예를 들어,
   "locale.strxfrm()" 은 로케일 특정 방식을 따르는 정렬 키를 만드는 데
   사용된다.

   A number of tools in Python accept key functions to control how
   elements are ordered or grouped.  They include "min()", "max()",
   "sorted()", "list.sort()", "heapq.nsmallest()", "heapq.nlargest()",
   and "itertools.groupby()".

   There are several ways to create a key function.  For example. the
   "str.lower()" method can serve as a key function for case
   insensitive sorts.  Alternatively, an ad-hoc key function can be
   built from a "lambda" expression such as "lambda r: (r[0], r[2])".
   Also, the "operator" module provides three key function
   constructors: "attrgetter()", "itemgetter()", and "methodcaller()".
   See the Sorting HOW TO for examples of how to create and use key
   functions.

keyword argument (키워드 인자)
   *인자* 를 보세요.

lambda (람다)
   호출될 때 값이 구해지는 하나의 *표현식* 으로 구성된 이름 없는 인라
   인 함수. 람다 함수를 만드는 문법은 "lambda [parameters]:
   expression" 이다.

LBYL
   뛰기 전에 보라 (Look before you leap). 이 코딩 스타일은 호출이나 조
   회를 하기 전에 명시적으로 사전 조건들을 검사한다. 이 스타일은
   *EAFP* 접근법과 대비되고, 많은 "if" 문의 존재로 특징지어진다.

   다중 스레드 환경에서, LBYL 접근법은 "보기"와 "뛰기" 간에 경쟁 조건
   을 만들게 될 위험이 있다. 예를 들어, 코드 "if key in mapping:
   return mapping[key]" 는 검사 후에, 하지만 조회 전에, 다른 스레드가
   *key* 를 *mapping* 에서 제거하면 실패할 수 있다. 이런 이슈는 록이나
   EAFP 접근법을 사용함으로써 해결될 수 있다.

list (리스트)
   A built-in Python *sequence*.  Despite its name it is more akin to
   an array in other languages than to a linked list since access to
   elements is O(1).

list comprehension (리스트 컴프리헨션)
   A compact way to process all or part of the elements in a sequence
   and return a list with the results.  "result = ["0x%02x" % x for x
   in range(256) if x % 2 == 0]" generates a list of strings
   containing even hex numbers (0x..) in the range from 0 to 255. The
   "if" clause is optional.  If omitted, all elements in "range(256)"
   are processed.

loader (로더)
   An object that loads a module. It must define a method named
   "load_module()". A loader is typically returned by a *finder*. See
   **PEP 302** for details.

magic method
   An informal synonym for *special method*.

mapping (매핑)
   A container object that supports arbitrary key lookups and
   implements the methods specified in the "Mapping" or
   "MutableMapping" abstract base classes.  Examples include "dict",
   "collections.defaultdict", "collections.OrderedDict" and
   "collections.Counter".

metaclass (메타 클래스)
   클래스의 클래스. 클래스 정의는 클래스 이름, 클래스 딕셔너리, 베이스
   클래스들의 목록을 만든다. 메타 클래스는 이 세 인자를 받아서 클래스
   를 만드는 책임을 진다. 대부분의 객체 지향형 프로그래밍 언어들은 기
   본 구현을 제공한다. 파이썬을 특별하게 만드는 것은 커스텀 메타 클래
   스를 만들 수 있다는 것이다. 대부분 사용자에게는 이 도구가 전혀 필요
   없지만, 필요가 생길 때, 메타 클래스는 강력하고 우아한 해법을 제공한
   다. 어트리뷰트 액세스의 로깅(logging), 스레드 안전성의 추가, 객체
   생성 추적, 싱글톤 구현과 많은 다른 작업에 사용됐다.

   클래스 생성 커스터마이제이션 에서 더 자세한 내용을 찾을 수 있다.

method (메서드)
   클래스 바디 안에서 정의되는 함수. 그 클래스의 인스턴스의 어트리뷰트
   로서 호출되면, 그 메서드는 첫 번째 *인자* (보통 "self" 라고 불린다)
   로 인스턴스 객체를 받는다. *함수* 와 *중첩된 스코프* 를 보세요.

method resolution order (메서드 결정 순서)
   메서드 결정 순서는 조회하는 동안 멤버를 검색하는 베이스 클래스들의
   순서다. 2.3 릴리스부터 파이썬 인터프리터에 사용된 알고리즘의 상세한
   내용은 The Python 2.3 Method Resolution Order 를 보면 된다.

module (모듈)
   파이썬 코드의 조직화 단위를 담당하는 객체. 모듈은 임의의 파이썬 객
   체들을 담는 이름 공간을 갖는다. 모듈은 *임포팅* 절차에 의해 파이썬
   으로 로드된다.

   *패키지* 도 보세요.

MRO
   *메서드 결정 순서* 를 보세요.

mutable (가변)
   가변 객체는 값이 변할 수 있지만 "id()" 는 일정하게 유지한다. *불변*
   도 보세요.

named tuple (네임드 튜플)
   인덱싱할 수 있는 요소들을 이름 붙은 어트리뷰트로도 액세스할 수 있는
   모든 튜플류 클래스 (예를 들어, "time.localtime()" 은 *year* 가
   "t[0]" 처럼 인덱스로도, "t.tm_year" 처럼 어트리뷰트로도 액세스할 수
   있는 튜플류 객체를 돌려준다.)

   네임드 튜플은 "time.struct_time" 같은 내장형일 수도, 일반 클래스 정
   의로 만들 수도 있다. 모든 기능이 구현된 네임드 튜플을 팩토리 함수
   "collections.namedtuple()" 로도 만들 수 있다. 마지막 접근법은
   "Employee(name='jones', title='programmer')" 와 같은 스스로 문서로
   만드는 repr 과 같은 확장 기능도 자동 제공한다.

namespace (이름 공간)
   The place where a variable is stored.  Namespaces are implemented
   as dictionaries.  There are the local, global and built-in
   namespaces as well as nested namespaces in objects (in methods).
   Namespaces support modularity by preventing naming conflicts.  For
   instance, the functions "__builtin__.open()" and "os.open()" are
   distinguished by their namespaces.  Namespaces also aid readability
   and maintainability by making it clear which module implements a
   function.  For instance, writing "random.seed()" or
   "itertools.izip()" makes it clear that those functions are
   implemented by the "random" and "itertools" modules, respectively.

nested scope (중첩된 스코프)
   The ability to refer to a variable in an enclosing definition.  For
   instance, a function defined inside another function can refer to
   variables in the outer function.  Note that nested scopes work only
   for reference and not for assignment which will always write to the
   innermost scope.  In contrast, local variables both read and write
   in the innermost scope.  Likewise, global variables read and write
   to the global namespace.

new-style class (뉴스타일 클래스)
   Any class which inherits from "object".  This includes all built-in
   types like "list" and "dict".  Only new-style classes can use
   Python's newer, versatile features like "__slots__", descriptors,
   properties, and "__getattribute__()".

   More information can be found in New-style and classic classes.

object (객체)
   상태 (어트리뷰트나 값) 를 갖고 동작 (메서드) 이 정의된 모든 데이터.
   또한, 모든 *뉴스타일 클래스* 의 최종적인 베이스 클래스다.

package (패키지)
   서브 모듈들이나, 재귀적으로 서브 패키지들을 포함할 수 있는 파이썬 *
   모듈*. 기술적으로, 패키지는 "__path__" 어트리뷰트가 있는 파이썬 모
   듈이다.

parameter (파라미터)
   A named entity in a *function* (or method) definition that
   specifies an *argument* (or in some cases, arguments) that the
   function can accept.  There are four types of parameters:

   * *위치-키워드 (positional-or-keyword)*: *위치 인자* 나 *키워드
     인 자* 로 전달될 수 있는 인자를 지정한다. 이것이 기본 형태의 파라
     미 터다, 예를 들어 다음에서 *foo* 와 *bar*:

        def func(foo, bar=None): ...

   * *위치-전용 (positional-only)*: 위치로만 제공될 수 있는 인자를
     지 정한다. 파이썬은 위치-전용 파라미터를 정의하는 문법을 갖고 있
     지 않다. 하지만, 어떤 매장 함수들은 위치-전용 파라미터를 갖는다 (
     예 를 들어, "abs()").

   * *가변-위치 (var-positional)*: (다른 파라미터들에 의해서 이미 받
     아 들여진 위치 인자들에 더해) 제공될 수 있는 위치 인자들의 임의의
     시 퀀스를 지정한다. 이런 파라미터는 파라미터 이름에 "*" 를 앞에
     붙여 서 정의될 수 있다, 예를 들어 다음에서 *args*:

        def func(*args, **kwargs): ...

   * *가변-키워드 (var-keyword)*: (다른 파라미터들에 의해서 이미 받
     아 들여진 키워드 인자들에 더해) 제공될 수 있는 임의의 개수 키워드
     인 자들을 지정한다. 이런 파라미터는 파라미터 이름에 "**" 를 앞에
     붙 여서 정의될 수 있다, 예를 들어 위의 예 에서 *kwargs*.

   파라미터는 선택적 인자들을 위한 기본값뿐만 아니라 선택적이거나 필수
   인자들을 지정할 수 있다.

   See also the *argument* glossary entry, the FAQ question on the
   difference between arguments and parameters, and the 함수 정의
   section.

PEP
   파이썬 개선 제안. PEP는 파이썬 커뮤니티에 정보를 제공하거나 파이썬
   또는 그 프로세스 또는 환경에 대한 새로운 기능을 설명하는 설계 문서
   다. PEP는 제안된 기능에 대한 간결한 기술 사양 및 근거를 제공해야 한
   다.

   PEP는 주요 새로운 기능을 제안하고 문제에 대한 커뮤니티 입력을 수집
   하며 파이썬에 들어간 설계 결정을 문서로 만들기 위한 기본 메커니즘이
   다. PEP 작성자는 커뮤니티 내에서 합의를 구축하고 반대 의견을 문서화
   할 책임이 있다.

   **PEP 1** 참조하세요.

positional argument (위치 인자)
   *인자* 를 보세요.

Python 3000 (파이썬 3000)
   파이썬 3.x 배포 라인의 별명 (버전 3의 배포가 먼 미래의 이야기던 시
   절에 만들어진 이름이다.) 이것을 "Py3k" 로 줄여 쓰기도 한다.

Pythonic (파이썬다운)
   다른 언어들에서 일반적인 개념들을 사용해서 코드를 구현하는 대신, 파
   이썬 언어에서 가장 자주 사용되는 이디엄들을 가까이 따르는 아이디어
   나 코드 조작. 예를 들어, 파이썬에서 자주 쓰는 이디엄은 "for" 문을
   사용해서 이터러블의 모든 요소로 루핑하는 것이다. 다른 많은 언어에는
   이런 종류의 구성물이 없으므로, 파이썬에 익숙하지 않은 사람들은 대신
   에 숫자 카운터를 사용하기도 한다:

      for i in range(len(food)):
          print food[i]

   더 깔끔한, 파이썬다운 방법은 이렇다:

      for piece in food:
          print piece

reference count (참조 횟수)
   객체에 대한 참조의 개수. 객체의 참조 횟수가 0으로 떨어지면, 메모리
   가 반납된다. 참조 횟수 추적은 일반적으로 파이썬 코드에 노출되지는
   않지만, *CPython* 구현의 핵심 요소다. "sys" 모듈은 특정 객체의 참조
   횟수를 돌려주는 "getrefcount()" 을 정의한다.

__slots__
   A declaration inside a *new-style class* that saves memory by pre-
   declaring space for instance attributes and eliminating instance
   dictionaries.  Though popular, the technique is somewhat tricky to
   get right and is best reserved for rare cases where there are large
   numbers of instances in a memory-critical application.

sequence (시퀀스)
   An *iterable* which supports efficient element access using integer
   indices via the "__getitem__()" special method and defines a
   "len()" method that returns the length of the sequence. Some built-
   in sequence types are "list", "str", "tuple", and "unicode". Note
   that "dict" also supports "__getitem__()" and "__len__()", but is
   considered a mapping rather than a sequence because the lookups use
   arbitrary *immutable* keys rather than integers.

slice (슬라이스)
   An object usually containing a portion of a *sequence*.  A slice is
   created using the subscript notation, "[]" with colons between
   numbers when several are given, such as in "variable_name[1:3:5]".
   The bracket (subscript) notation uses "slice" objects internally
   (or in older versions, "__getslice__()" and "__setslice__()").

special method (특수 메서드)
   파이썬이 형에 어떤 연산을, 덧셈 같은, 실행할 때 묵시적으로 호출되는
   메서드. 이런 메서드는 두 개의 밑줄로 시작하고 끝나는 이름을 갖고 있
   다. 특수 메서드는 특수 메서드 이름들 에 문서로 만들어져 있다.

statement (문장)
   문장은 스위트 (코드의 "블록(block)") 를 구성하는 부분이다. 문장은 *
   표현식* 이거나 키워드를 사용하는 여러 가지 구조물 중의 하나다. 가령
   "if", "while", "for".

struct sequence (구조체 시퀀스)
   A tuple with named elements. Struct sequences expose an interface
   similiar to *named tuple* in that elements can be accessed either
   by index or as an attribute. However, they do not have any of the
   named tuple methods like "_make()" or "_asdict()". Examples of
   struct sequences include "sys.float_info" and the return value of
   "os.stat()".

triple-quoted string (삼중 따옴표 된 문자열)
   따옴표 (") 나 작은따옴표 (') 세 개로 둘러싸인 문자열. 그냥 따옴표
   하나로 둘러싸인 문자열에 없는 기능을 제공하지는 않지만, 여러 가지
   이유에서 쓸모가 있다. 이스케이프 되지 않은 작은따옴표나 큰따옴표를
   문자열 안에 포함할 수 있도록 하고, 연결 문자를 쓰지 않고도 여러 줄
   에 걸칠 수 있는데, 독스트링을 쓸 때 특히 쓸모 있다.

type (형)
   파이썬 객체의 형은 그것이 어떤 종류의 객체인지를 결정한다; 모든 객
   체는 형이 있다. 객체의 형은 "__class__" 어트리뷰트로 액세스할 수 있
   거나 "type(obj)" 로 얻을 수 있다.

universal newlines (유니버설 줄 넘김)
   A manner of interpreting text streams in which all of the following
   are recognized as ending a line: the Unix end-of-line convention
   "'\n'", the Windows convention "'\r\n'", and the old Macintosh
   convention "'\r'".  See **PEP 278** and **PEP 3116**, as well as
   "str.splitlines()" for an additional use.

virtual environment (가상 환경)
   파이썬 사용자와 응용 프로그램이, 같은 시스템에서 실행되는 다른 파이
   썬 응용 프로그램들의 동작에 영향을 주지 않으면서, 파이썬 배포 패키
   지들을 설치하거나 업그레이드하는 것을 가능하게 하는, 협력적으로 격
   리된 실행 환경.

virtual machine (가상 기계)
   소프트웨어만으로 정의된 컴퓨터. 파이썬의 가상 기계는 바이트 코드 컴
   파일러가 출력하는 *바이트 코드* 를 실행한다.

Zen of Python (파이썬 젠)
   파이썬 디자인 원리와 철학들의 목록인데, 인어를 이해하고 사용하는 데
   도움이 된다. 이 목록은 대화형 프롬프트에서 ""import this"" 를 입력
   하면 보인다.
