프로그래밍 FAQ¶
일반적인 질문¶
중단점과 단일 단계 실행(single-stepping) 기능이 있는 소스 코드 수준의 디버거가 있습니까?¶
예.
파이썬을 위한 여러 디버거가 아래에 설명되어 있으며, 내장 함수 breakpoint()를 사용하면 이들 중 하나로 들어갈 수 있습니다.
pdb 모듈은 간단하지만 적절한 파이썬 용 콘솔 모드 디버거입니다. 표준 파이썬 라이브러리의 일부이며, 라이브러리 레퍼런스 매뉴얼에서 설명하고 있습니다. pdb의 코드를 예로 사용하여 자체 디버거를 작성할 수도 있습니다.
표준 Python 배포판의 일부인 IDLE 대화형 개발 환경(보통 idlelib 으로 제공됨)에는 그래픽 디버거가 포함되어 있습니다.
PythonWin은 pdb 기반의 GUI 디버거를 포함하는 Python IDE입니다. PythonWin 디버거는 중단점에 색상을 입히고, non-PythonWin 프로그램을 디버깅하는 등 여러 유용한 기능을 제공합니다. PythonWin은 pywin32 프로젝트와 ActivePython 배포판의 일부로 사용할 수 있습니다.
Eric 는 PyQt 및 Scintilla 편집 컴포넌트를 기반으로 구축된 IDE입니다.
trepan3k 는 gdb와 유사한 디버거입니다.
Visual Studio Code 는 버전 관리 소프트웨어와 통합되는 디버깅 도구를 갖춘 IDE입니다.
그래픽 디버거를 포함하는 많은 상용 파이썬 IDE가 있습니다. 다음을 포함합니다:
버그를 찾거나 정적 분석을 수행하는 데 도움이 되는 도구가 있습니까?¶
예.
Ruff, ` Pylint <https://pylint.readthedocs.io/>`__ 및 ` Pyflakes <https://github.com/PyCQA/pyflakes>`__은 버그를 더 빨리 발견할 수 있게 돕는 기본 검사 기능을 제공합니다.
mypy, ` ty <https://docs.astral.sh/ty/>`__, ` Pyrefly <https://pyrefly.org/>`__, 그리고 ` pytype <https://github.com/google/pytype>`__와 같은 정적 타입 검사기는 Python 소스 코드의 타입 힌트를 확인할 수 있습니다.
파이썬 스크립트로 독립 실행형 바이너리를 만들려면 어떻게 해야 합니까?¶
사용자가 파이썬 배포를 먼저 설치하지 않고도 다운로드하여 실행할 수 있는 독립 실행형 프로그램을 원하는 것이 전부라면 파이썬을 C 코드로 컴파일하는 기능이 필요하지는 않습니다. 프로그램에 필요한 모듈 집합을 파악하고 이러한 모듈들을 파이썬 바이너리와 결합하여 단일 실행 파일을 생성하는 많은 도구가 있습니다.
하나는 freeze 도구를 사용하는 것입니다. 이 도구는 Python 소스 트리의 Tools/freeze 에 포함되어 있으며, Python 바이트 코드를 C 배열로 변환합니다. C 컴파일러를 사용하여 모든 모듈을 새 프로그램에 삽입한 후 표준 Python 모듈과 연결할 수 있습니다.
소스를 재귀적으로 검색하여 import 문(두 형식 모두)을 찾고 표준 파이썬 경로뿐만 아니라 소스 디렉터리에서 모듈을 찾습니다 (내장할 모듈을 위해). 그런 다음 파이썬으로 작성된 모듈의 바이트 코드를 C 코드 (marshal 모듈을 사용하여 코드 객체로 변환할 수 있는 배열 초기화기)로 바꾸고 프로그램에서 실제로 사용되는 내장 모듈만 포함하는 특별한 구성 파일을 만듭니다. 그런 다음 생성된 C 코드를 컴파일하고 이를 나머지 파이썬 인터프리터와 링크하여 스크립트와 똑같게 작동하는 자체 포함 바이너리를 형성합니다.
다음 패키지들이 콘솔 및 GUI 실행 파일 제작을 도와줄 수 있습니다:
Nuitka (크로스 플랫폼)
PyInstaller (크로스 플랫폼)
PyOxidizer (크로스 플랫폼)
cx_Freeze (크로스 플랫폼)
py2app (macOS 전용)
py2exe (Windows 전용)
파이썬 프로그램을 위한 코딩 표준이나 스타일 지침서가 있습니까?¶
예. 표준 라이브러리 모듈에 요구되는 코딩 스타일은 PEP 8에서 설명합니다.
핵심 언어¶
변수에 값이 있을 때 UnboundLocalError 가 발생하는 이유는 무엇입니까?¶
함수 본문 어딘가에 할당 문장을 추가하여 수정했을 때, 기존에 잘 작동하던 코드에서 UnboundLocalError 가 발생하면 당황스러울 수 있습니다.
이 코드는:
>>> x = 10
>>> def bar():
... print(x)
...
>>> bar()
10
작동하지만, 이 코드는:
>>> x = 10
>>> def foo():
... print(x)
... x += 1
UnboundLocalError 이(가) 발생함:
>>> foo()
Traceback (most recent call last):
...
UnboundLocalError: cannot access local variable 'x' where it is not associated with a value
이는 스코프에서 변수에 대입할 때, 해당 변수가 그 스코프에 대해 지역(local)이 되고 외부 스코프에서 비슷한 이름의 변수를 가리기 때문입니다. foo의 마지막 문장은 x에 새 값을 대입하므로, 컴파일러는 이 값을 지역 변수로 인식합니다. 결과적으로 앞의 print(x)가 초기화되지 않은 지역 변수를 인쇄하려고 할 때 에러가 발생합니다.
위의 예에서 변수를 전역(global)으로 선언하여 외부 스코프 변수에 액세스 할 수 있습니다:
>>> x = 10
>>> def foobar():
... global x
... print(x)
... x += 1
...
>>> foobar()
10
이 명시적 선언은 (클래스와 인스턴스 변수의 표면적으로 유사한 상황과 달리) 실제로 외부 스코프에 있는 변수의 값을 수정하고 있음을 상기시키기 위해 필요합니다:
>>> print(x)
11
nonlocal 키워드를 사용하여 중첩된 스코프에서 비슷한 일을 할 수 있습니다:
>>> def foo():
... x = 10
... def bar():
... nonlocal x
... print(x)
... x += 1
... bar()
... print(x)
...
>>> foo()
10
11
파이썬에서 지역과 전역 변수에 대한 규칙은 무엇입니까?¶
파이썬에서, 함수 내에서 참조되기만 하는 변수는 묵시적으로 전역입니다. 변수가 함수 본문 내 어디에서건 값을 대입하면, 명시적으로 전역으로 선언되지 않는 한 지역으로 간주합니다.
처음에는 조금 의외지만, 잠시 생각해보면 이해가 됩니다. 한편으로, 대입된 변수에 global을 요구하면 의도하지 않은 부작용에 대한 저지선을 제공합니다. 반면에, 모든 전역 참조에 global이 요구된다면, 항상 global을 사용하게 됩니다. 내장 함수나 임포트 한 모듈의 구성 요소에 대한 모든 참조를 전역으로 선언해야 합니다. 이 혼란은 부작용을 식별하기 위한 global 선언의 유용성을 무효로 합니다.
다른 값으로 루프에서 정의된 람다는 왜 모두 같은 결과를 반환합니까?¶
몇 가지 다른 람다(또는 일반 함수들)를 정의하기 위해 for 루프를 사용한다고 가정하십시오. 예시:
>>> squares = []
>>> for x in range(5):
... squares.append(lambda: x**2)
이것은 x**2를 계산하는 5개의 람다가 포함된 리스트를 제공합니다. 호출되면, 각각 0, 1, 4, 9 및 16을 반환할 것으로 예상할 수 있습니다. 그러나, 실제로 시도하면 모두 16을 반환한다는 것을 알 수 있습니다:
>>> squares[2]()
16
>>> squares[4]()
16
이것은 x 가 람다의 지역 변수가 아니라 외부 스코프에 정의되어 있고, 람다가 정의될 때가 아니라 호출될 때 접근되기 때문에 발생합니다. 루프가 끝날 때 x 의 값은 4 이므로 모든 함수는 이제 4**2 인 16 을 반환합니다. 또한 x 의 값을 변경하여 람다 결과가 어떻게 변하는지 확인해 볼 수 있습니다:
>>> x = 8
>>> squares[2]()
64
이를 피하려면, 람다에 대해 지역인 변수에 값을 저장하여, 전역 x의 값에 의존하지 않도록 할 필요가 있습니다:
>>> squares = []
>>> for x in range(5):
... squares.append(lambda n=x: n**2)
여기서 n=x는 람다에 지역인 새 변수 n을 만들고, 루프의 해당 시점에서 x 와 같은 값을 갖도록 람다가 정의될 때 계산됩니다. 이는 n의 값이 첫 번째 람다에서 0, 두 번째에서 1, 세 번째에서 2 등이 됨을 의미합니다. 따라서 각 람다는 이제 올바른 결과를 반환합니다:
>>> squares[2]()
4
>>> squares[4]()
16
이 동작은 람다에만 국한된 것이 아니라 일반 함수에도 적용됩니다.
모듈에서 임포트를 사용하는 “모범 사례”는 무엇입니까?¶
일반적으로, from modulename import *를 사용하지 마십시오. 그렇게 하면 임포트 하는 곳의 이름 공간이 어수선해지고, 린터(linter)가 정의되지 않은 이름을 감지하기가 훨씬 어려워집니다.
파일 맨 위에서 모듈을 임포트 하십시오. 그렇게 하면 코드에 필요한 다른 모듈을 명확하게 하고 모듈 이름이 스코프에 있는지에 대한 질문을 피할 수 있습니다. 한 줄에 하나의 임포트를 사용하면 모듈 임포트를 쉽게 추가하고 삭제할 수 있지만, 한 줄에 여러 임포트를 사용하면 화면 공간을 덜 사용합니다.
다음 순서로 모듈을 임포트 하는 것이 좋습니다:
순환 임포트 관련 문제를 피하고자 임포트를 함수나 클래스로 이동해야 하는 경우가 있습니다. Gordon McMillan은 다음과 같이 말했습니다:
두 모듈 모두 “import <module>” 형식의 임포트를 사용하면 순환 임포트는 괜찮습니다. 두 번째 모듈이 첫 번째 모듈의 이름(name)을 붙잡으려고 하고 (“from module import name”) 임포트가 최상위 수준에 있으면 실패합니다. 첫 번째 모듈이 두 번째 모듈을 임포트 하는 중이라서 첫 번째 모듈에 있는 이름을 아직 사용할 수 없기 때문입니다.
이 경우, 두 번째 모듈이 하나의 함수에서만 사용된다면, 임포트를 해당 함수로 쉽게 이동할 수 있습니다. 임포트가 호출될 때, 첫 번째 모듈의 초기화가 완료되었고, 두 번째 모듈은 임포트를 수행할 수 있습니다.
일부 모듈이 플랫폼 특정이면 임포트를 코드의 최상위 수준에서 다른 곳으로 이동해야 할 수도 있습니다. 이 경우, 파일 맨 위에서 모든 모듈을 임포트 하는 것이 가능하지 않을 수도 있습니다. 이 경우, 해당 플랫폼 특정 코드에서 올바른 모듈을 임포트 하는 것이 좋은 선택입니다.
순환 임포트를 피하거나 모듈의 초기화 시간을 줄이려는 등의 문제를 해결하는 데 필요할 때만, 함수 정의 내부와 같은 지역 스코프로 임포트를 옮기십시오. 이 기법은 프로그램 실행 방법에 따라 많은 임포트가 필요하지 않을 때 특히 유용합니다. 모듈이 해당 함수에서만 사용될 때 임포트를 함수로 옮기고 싶을 수도 있습니다. 모듈의 일회성 초기화 때문에 모듈을 처음 로드하는 데 비용이 많이들 수 있지만, 모듈을 여러 번 로드하는 것은 사실상 무료임에 유의하십시오, 두 번의 딕셔너리 조회만 발생합니다. 모듈 이름이 스코프를 벗어난 경우에도, 모듈은 아마도 sys.modules에 있을 겁니다.
한 함수에서 다른 함수로 선택적이나 키워드 매개변수를 전달하려면 어떻게 해야 합니까?¶
함수의 매개변수 목록에 *와 ** 지정자를 사용하여 인자를 수집하십시오; 이것은 위치 인자를 튜플로, 키워드 인자를 딕셔너리로 제공합니다. 그런 다음 *와 **를 사용하여 다른 함수를 호출할 때 이러한 인자를 전달할 수 있습니다:
def f(x, *args, **kwargs):
...
kwargs['width'] = '14.3c'
...
g(x, *args, **kwargs)
인자와 매개변수의 차이점은 무엇입니까?¶
Parameters 는 함수 정의에 나타나는 이름으로 정의되며, arguments 는 함수 호출 시 실제로 전달되는 값입니다. Parameters는 함수가 어떤 종류의 인자 를 수용할 수 있는지를 정의합니다. 예를 들어, 다음 함수 정의를 보십시오:
def func(foo, bar=None, **kwargs):
pass
foo, bar 및 kwargs는 func의 매개변수입니다. 그러나, func를 호출할 때, 예를 들면:
func(42, bar=314, extra=somevar)
42, 314 및 somevar 값은 인자입니다.
리스트 ‘y’를 변경할 때 리스트 ‘x’도 변경되는 이유는 무엇입니까?¶
다음과 같은 코드를 작성하면:
>>> x = []
>>> y = x
>>> y.append(10)
>>> y
[10]
>>> x
[10]
y에 요소를 추가하면 x도 변경되는 이유가 궁금할 것입니다.
이 결과를 만드는 두 가지 요소가 있습니다:
변수는 단순히 객체를 가리키는 이름입니다.
y = x를 수행하면 리스트의 사본을 만들지 않습니다 –x가 참조하는 것과 같은 객체를 참조하는 새 변수y를 만듭니다. 이는 하나의 객체(리스트)만 있고,x와y모두 그 객체를 참조함을 의미합니다.리스트는 가변입니다, 내용을 변경할 수 있다는 뜻입니다.
append() 호출 후 가변 객체의 내용이 [] 에서 [10] 으로 변경되었습니다. 두 변수 모두 동일한 객체를 참조하므로 어느 쪽 이름을 사용하든 수정된 값인 [10] 에 접근하게 됩니다.
대신 불변 객체를 x에 대입하면:
>>> x = 5 # int는 불변임
>>> y = x
>>> x = x + 1 # 5를 변형할 수 없으므로, 여기서 새로운 객체를 생성함
>>> x
6
>>> y
5
이 경우 x 와 y가 더는 같지 않다는 것을 알 수 있습니다. 이는 정수가 불변이기 때문이고, x = x + 1을 수행할 때 값을 증가시켜서 정수 5를 변경하는 것이 아닙니다; 대신 새 객체(정수 6)를 만들어 x에 대입합니다 (즉, x가 참조하는 객체를 바꿉니다). 이 대입 후에는 두 개의 객체(정수 6과 5)와 이를 참조하는 두 개의 변수를 갖게 됩니다 (x는 이제 6을 참조하지만, y는 여전히 5를 참조합니다).
일부 연산(예를 들어 y.append(10) 및 y.sort())은 객체를 변형하며, 겉보기에 유사한 다른 연산(예를 들어 y = y + [10] 및 sorted(y))은 새로운 객체를 생성합니다. 일반적으로 파이썬에서는(그리고 표준 라이브러리의 모든 경우에서) 객체를 변형하는 메서드는 두 가지 유형의 연산을 혼동하지 않도록 None 을 반환합니다. 따라서 만약 y.sort() 가 y 의 정렬된 복사본을 제공할 것이라고 잘못 생각하고 작성하면, 대신 None 이 반환되며 이는 프로그램에서 쉽게 진단 가능한 오류를 발생시킬 것입니다.
그러나, 같은 연산이 때때로 형에 따라 다른 동작을 갖는 한 가지 연산 클래스가 있습니다: 증분 대입 연산자. 예를 들어, +=는 리스트를 변경하지만, 튜플이나 정수는 변경하지 않습니다 (a_list += [1, 2, 3]은 a_list.extend([1, 2, 3])과 동등하고 a_list를 변경하지만, some_tuple += (1, 2, 3)과 some_int += 1은 새 객체를 만듭니다).
달리 표현하면:
출력 매개변수가 있는 함수를 작성하려면 어떻게 해야 합니까 (참조에 의한 호출)?¶
파이썬에서는 인자가 대입에 의해 전달됨을 기억하십시오. 대입은 단순히 객체에 대한 참조를 생성하므로, 호출자와 피호출자의 인자 이름 사이에 별칭(alias)이 없으며 결과적으로 참조에 의한 호출(call-by-reference)도 아닙니다. 원하는 효과는 여러 가지 방법으로 구현할 수 있습니다.
결과의 튜플을 반환하여:
>>> def func1(a, b): ... a = 'new-value' # a와 b는 지역 이름 ... b = b + 1 # 새 객체에 할당됨 ... return a, b # 새로운 값 반환 ... >>> x, y = 'old-value', 99 >>> func1(x, y) ('new-value', 100)
이것은 거의 항상 가장 명확한 해법입니다.
전역 변수를 사용하여. 이것은 스레드 안전하지 않고, 권장하지 않습니다.
가변 (제자리에서 변경할 수 있는) 객체를 전달하여:
>>> def func2(a): ... a[0] = 'new-value' # 'a'는 가변 리스트를 참조함 ... a[1] = a[1] + 1 # 공유된 객체를 변경함 ... >>> args = ['old-value', 99] >>> func2(args) >>> args ['new-value', 100]
변경되는 딕셔너리를 전달하여:
>>> def func3(args): ... args['a'] = 'new-value' # args는 가변 딕셔너리임 ... args['b'] = args['b'] + 1 # 제자리에서 변경 ... >>> args = {'a': 'old-value', 'b': 99} >>> func3(args) >>> args {'a': 'new-value', 'b': 100}
또는 클래스 인스턴스에 값을 묶어서:
>>> class Namespace: ... def __init__(self, /, **args): ... for key, value in args.items(): ... setattr(self, key, value) ... >>> def func4(args): ... args.a = 'new-value' # args는 가변 Namespace임 ... args.b = args.b + 1 # 객체를 제자리에서 변경 ... >>> args = Namespace(a='old-value', b=99) >>> func4(args) >>> vars(args) {'a': 'new-value', 'b': 100}
이렇게 복잡하게 만들어야 할 좋은 이유는 거의 없습니다.
최선의 선택은 여러 결과가 포함된 튜플을 반환하는 것입니다.
파이썬에서 고차 함수(higher order function)를 어떻게 만드나요?¶
두 가지 선택이 있습니다: 중첩된 스코프를 사용하거나 콜러블 객체를 사용할 수 있습니다. 예를 들어, 값 a*x+b를 계산하는 함수 f(x)를 반환하는 linear(a,b)를 정의하려고 한다고 가정하십시오. 중첩된 스코프를 사용해서:
def linear(a, b):
def result(x):
return a * x + b
return result
또는 콜러블 객체를 사용해서:
class linear:
def __init__(self, a, b):
self.a, self.b = a, b
def __call__(self, x):
return self.a * x + self.b
두 경우 모두,
taxes = linear(0.3, 2)
taxes(10e6) == 0.3 * 10e6 + 2가 되도록 하는 콜러블 객체를 제공합니다.
콜러블 객체 접근 방식은 약간 느리고 코드가 약간 길어진다는 단점이 있습니다. 그러나, 콜러블 컬렉션은 상속을 통해 서명을 공유할 수 있습니다:
class exponential(linear):
# __init__ 상속됨
def __call__(self, x):
return self.a * (x ** self.b)
객체는 여러 메서드의 상태를 캡슐화 할 수 있습니다:
class counter:
value = 0
def set(self, x):
self.value = x
def up(self):
self.value = self.value + 1
def down(self):
self.value = self.value - 1
count = counter()
inc, dec, reset = count.up, count.down, count.set
여기서 inc(), dec() 및 reset()은 같은 계수 변수를 공유하는 함수처럼 작동합니다.
파이썬에서 객체를 어떻게 복사합니까?¶
일반적으로, 일반적일 때 copy.copy()나 copy.deepcopy()를 시도하십시오. 모든 객체를 복사할 수는 없지만, 대부분 가능합니다.
일부 객체는 더 쉽게 복사할 수 있습니다. 딕셔너리에는 copy() 메서드가 있습니다:
newdict = olddict.copy()
시퀀스는 슬라이싱으로 복사할 수 있습니다:
new_l = l[:]
객체의 메서드나 어트리뷰트를 어떻게 찾을 수 있습니까?¶
사용자가 정의한 클래스의 인스턴스 x 에 대해, dir(x) 은 인스턴스 속성 및 해당 클래스에서 정의된 메서드와 속성을 포함하는 알파벳순의 이름 리스트를 반환합니다.
코드에서 객체 이름을 어떻게 찾을 수 있습니까?¶
일반적으로 말하자면, 객체에는 실제로 이름이 없기 때문에 그럴 수 없습니다. 기본적으로, 대입은 항상 이름을 값에 연결합니다; def와 class 문의 경우도 마찬가지이지만, 이 경우 값은 콜러블입니다. 다음 코드를 고려하십시오:
>>> class A:
... pass
...
>>> B = A
>>> a = B()
>>> b = a
>>> print(b)
<__main__.A object at 0x16D07CC>
>>> print(a)
<__main__.A object at 0x16D07CC>
이론적으로 클래스는 이름을 가집니다. 비록 두 개의 이름에 바인딩되어 있고 이름 B 를 통해 호출되더라도, 생성된 인스턴스는 여전히 클래스 A 의 인스턴스로 보고됩니다. 그러나 두 이름이 동일한 값에 바인딩되어 있으므로, 인스턴스의 이름이 a 인지 b 인지 말하는 것은 불가능합니다.
일반적으로 말해 코드가 특정 값의 “이름을 알아야” 할 필요는 없습니다. 의도적으로 내성적인(introspective) 프로그램을 작성하지 않는 한, 이는 일반적으로 접근 방식의 변경이 도움이 될 수 있다는 신호입니다.
comp.lang.python에서, Fredrik Lundh는 언젠가 이 질문에 대해 훌륭한 비유를 했습니다:
여러분이 현관에서 발견한 고양이의 이름을 얻는 것과 같은 방법: 고양이(객체) 자체는 여러분에게 자신의 이름을 말할 수 없고, 전혀 신경 쓰지도 않습니다 – 따라서 그것이 어떻게 불리는지 알아내는 유일한 방법은 여러분 이웃 모두(이름 공간)에게 자신의 고양이(객체)인지 묻는 것입니다…
…. 여러 이름으로 알려져 있거나 전혀 이름이 없다는 것을 알게 되더라도 놀라지 마십시오!
쉼표 연산자의 우선순위는 어떻게 되나요?¶
쉼표는 파이썬에서 연산자가 아닙니다. 이 세션을 고려하십시오:
>>> "a" in "b", "a"
(False, 'a')
쉼표는 연산자가 아니라 표현식 사이의 구분자이기 때문에 위는 다음과 같이 입력한 것처럼 평가됩니다:
("a" in "b"), "a"
다음과 같이 평가되지 않습니다:
"a" in ("b", "a")
다양한 대입 연산자(=, += 등)도 마찬가지입니다. 이들은 실제 연산자가 아니라 대입 문에서의 구문 구분자입니다.
C의 “?:” 삼항 연산자와 동등한 것이 있습니까?¶
예, 있습니다. 문법은 다음과 같습니다:
[on_true] if [expression] else [on_false]
x, y = 50, 25
small = x if x < y else y
이 문법이 파이썬 2.5에서 소개되기 전에, 일반적인 관용구는 논리 연산자를 사용하는 것이었습니다:
[expression] and [on_true] or [on_false]
그러나, 이 관용구는 안전하지 않습니다. on_true가 거짓 불리언 값을 가질 때 잘못된 결과가 나올 수 있습니다. 따라서, 항상 ... if ... else ... 형식을 사용하는 것이 좋습니다.
파이썬에서 난독화된 한 줄 코드를 작성할 수 있습니까?¶
네. 보통 이는 lambda 내에 lambda 를 중첩하여 수행합니다. Ulf Bartelt에서 발췌하여 약간 수정한 다음 세 가지 예제를 참고하십시오.
from functools import reduce
# Primes < 1000
print(list(filter(None,map(lambda y:y*reduce(lambda x,y:x*y!=0,
map(lambda x,y=y:y%x,range(2,int(pow(y,0.5)+1))),1),range(2,1000)))))
# First 10 Fibonacci numbers
print(list(map(lambda x,f=lambda x,f:(f(x-1,f)+f(x-2,f)) if x>1 else 1:
f(x,f), range(10))))
# Mandelbrot set
print((lambda Ru,Ro,Iu,Io,IM,Sx,Sy:reduce(lambda x,y:x+'\n'+y,map(lambda y,
Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,Sy=Sy,L=lambda yc,Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,i=IM,
Sx=Sx,Sy=Sy:reduce(lambda x,y:x+y,map(lambda x,xc=Ru,yc=yc,Ru=Ru,Ro=Ro,
i=i,Sx=Sx,F=lambda xc,yc,x,y,k,f=lambda xc,yc,x,y,k,f:(k<=0)or (x*x+y*y
>=4.0) or 1+f(xc,yc,x*x-y*y+xc,2.0*x*y+yc,k-1,f):f(xc,yc,x,y,k,f):chr(
64+F(Ru+x*(Ro-Ru)/Sx,yc,0,0,i)),range(Sx))):L(Iu+y*(Io-Iu)/Sy),range(Sy
))))(-2.1, 0.7, -1.2, 1.2, 30, 80, 24))
# \___ ___/ \___ ___/ | | |__ lines on screen
# V V | |______ columns on screen
# | | |__________ maximum of "iterations"
# | |_________________ range on y axis
# |____________________________ range on x axis
집에서 이것을 시도하지 마십시오, 어린이들!
함수의 매개변수 목록에서 슬래시(/)는 무엇을 의미합니까?¶
함수의 인자 목록에 있는 슬래시(/)는 그 앞에 오는 매개변수가 위치 전용(positional-only)임을 나타냅니다. 위치 전용 매개변수는 외부에서 사용할 수 있는 이름이 없는 매개변수입니다. 위치 전용 매개변수를 허용하는 함수를 호출할 때, 인자는 오직 위치에 기반하여 매개변수에 매핑됩니다. 예를 들어, divmod() 은 위치 전용 매개변수를 수용하는 함수입니다. 해당 함수의 설명은 다음과 같습니다:
>>> help(divmod)
Help on built-in function divmod in module builtins:
divmod(x, y, /)
Return the tuple (x//y, x%y). Invariant: div*y + mod == x.
매개변수 목록 끝의 슬래시는 두 매개변수가 위치 전용임을 의미합니다. 따라서, 키워드 인자로 divmod()를 호출하면 에러가 발생합니다:
>>> divmod(x=3, y=4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: divmod() takes no keyword arguments
숫자와 문자열¶
16진수와 8진수 정수는 어떻게 지정합니까?¶
8진수를 지정하려면, 8진수 값 앞에 0을 붙이고, 소문자나 대문자 “o”를 붙입니다. 예를 들어, 변수 “a”를 8진수 값 “10”(10진수 8)으로 설정하려면, 이렇게 입력하십시오:
>>> a = 0o10
>>> a
8
16진수도 쉽습니다. 16진수 앞에 0을 붙이고, 소문자나 대문자 “x”를 붙이기만 하면 됩니다. 16진 숫자는 소문자나 대문자로 지정할 수 있습니다. 예를 들어, 파이썬 인터프리터에서:
>>> a = 0xa5
>>> a
165
>>> b = 0XB2
>>> b
178
왜 -22 // 10 이 -3을 반환합니까?¶
주로 i % j가 j와 같은 부호를 갖도록 하려는 것입니다. 여러분이 이것을 원하고, 다음과 같은 것도 원한다면:
i == (i // j) * j + (i % j)
정수 나누기는 floor를 반환해야 합니다. C 또한 이 항등식을 만족하도록 요구하고, i // j를 자르는(truncate) 컴파일러는 i % j가 i 와 같은 부호를 갖도록 할 필요가 있습니다.
j가 음수인 경우 i % j에 대한 실제 사용 사례는 거의 없습니다. j가 양수이면, 많은 사례가 있으며, 사실상 모든 경우에 i % j가 >= 0인 것이 더 유용합니다. 시계가 지금 10을 가리킨다면, 200시간 전에는 어디를 가리키겠습니까? -190 % 12 == 2가 유용합니다; -190 % 12 == -10은 물기를 기다리는 버그입니다.
SyntaxError 대신 int 리터럴 속성을 얻으려면 어떻게 해야 합니까?¶
일반적인 방식으로 int 리터럴 속성을 조회하려고 하면 마침표를 소수점으로 인식하기 때문에 SyntaxError 가 발생합니다:
>>> 1.__class__
File "<stdin>", line 1
1.__class__
^
SyntaxError: invalid decimal literal
해결 방법은 공백이나 괄호를 사용하여 리터럴과 마침표를 분리하는 것입니다.
>>> 1 .__class__
<class 'int'>
>>> (1).__class__
<class 'int'>
문자열을 숫자로 어떻게 변환합니까?¶
정수형의 경우 내장된 int() 타입 생성자를 사용하십시오. 예를 들어, int('144') == 144 와 같이 사용합니다. 마찬가지로, float() 은 부동 소수점 숫자로 변환하며, 예로 float('144') == 144.0 이 있습니다.
기본적으로 이것은 숫자를 심진수로 해석합니다. 그래서 int('0144') == 144는 참이고 int('0x144')는 ValueError를 발생시킵니다. int(string, base)는 두 번째 선택적 인자로 변환에 사용할 진수(base)를 받아들여서, int( '0x144', 16) == 324입니다. base가 0으로 지정되면, 숫자는 파이썬의 규칙을 사용하여 해석됩니다: 선행 ‘0o’는 8진수를 나타내고, ‘0x’는 16진수를 나타냅니다.
필요한 것이 문자열을 숫자로 변환하는 것뿐이라면 내장 함수 eval()을 사용하지 마십시오. eval()은 상당히 느리며 보안 위험을 초래할 수 있습니다: 누군가 원하지 않는 부작용이 있는 파이썬 표현식을 전달할 수 있습니다. 예를 들어, 누군가 여러분의 홈 디렉터리를 지우는 __import__('os').system("rm -rf $HOME")을 전달할 수 있습니다.
eval() 은 또한 숫자를 파이썬 표현식으로 해석하는 효과가 있으므로, 예를 들어 eval('09') 는 파이썬이 (단, ‘0’은 제외) 십진수에서 선행 ‘0’을 허용하지 않기 때문에 구문 에러를 발생시킵니다.
숫자를 문자열로 어떻게 변환합니까?¶
예를 들어, 숫자 144 를 문자열 '144' 로 변환하려면 내장 타입 생성자 str() 을 사용하십시오. 16진수나 8진수 표현이 필요한 경우 내장 함수인 hex() 또는 oct() 를 사용하십시오. 상세한 포맷팅은 포맷 문자열 리터럴 및 포맷 문자열 문법 섹션을 참조하십시오. 예를 들어, "{:04d}".format(144) 는 '0144' 를 반환하고 "{:.3f}".format(1.0/3.0) 은 '0.333' 을 반환합니다.
제자리에서 문자열을 어떻게 수정합니까?¶
문자열은 불변이므로 그렇게 할 수 없습니다. 대부분의 상황에서는 조립하려는 여러 부분으로부터 새 문자열을 생성하는 것이 좋습니다. 그러나 제자리에서 유니코드 데이터를 수정할 수 있는 능력을 가진 객체가 필요한 경우, io.StringIO 객체나 array 모듈을 사용해 보십시오:
>>> import io
>>> s = "Hello, world"
>>> sio = io.StringIO(s)
>>> sio.getvalue()
'Hello, world'
>>> sio.seek(7)
7
>>> sio.write("there!")
6
>>> sio.getvalue()
'Hello, there!'
>>> import array
>>> a = array.array('w', s)
>>> print(a)
array('w', 'Hello, world')
>>> a[0] = 'y'
>>> print(a)
array('w', 'yello, world')
>>> a.tounicode()
'yello, world'
문자열을 사용하여 어떻게 함수/메서드를 호출합니까?¶
다양한 기법이 있습니다.
문자열을 함수로 매핑하는 딕셔너리를 사용하는 것이 가장 좋습니다. 이 기법의 주요 장점은 문자열이 함수 이름과 일치할 필요가 없다는 것입니다. 이것은 또한 case 구문을 흉내 내는 데 사용되는 기본 기법입니다:
def a(): pass def b(): pass dispatch = {'go': a, 'stop': b} # Note lack of parens for funcs dispatch[get_input()]() # Note trailing parens to call function
내장 함수
getattr()을 사용하십시오:import foo getattr(foo, 'bar')()
getattr()은 클래스, 클래스 인스턴스, 모듈 등을 포함하는 모든 객체에서 작동함에 유의하십시오.이것은 다음과 같이 표준 라이브러리의 여러 곳에서 사용됩니다:
class Foo: def do_foo(self): ... def do_bar(self): ... f = getattr(foo_instance, 'do_' + opname) f()
함수 이름을 해석(resolve)하려면
locals()를 사용하십시오:def myFunc(): print("hello") fname = "myFunc" f = locals()[fname] f()
문자열 끝의 줄 바꿈을 제거하는 Perl의 chomp() 와 동일한 기능이 있습니까?¶
S.rstrip("\r\n")을 사용하면 다른 후행 공백을 제거하지 않고 문자열 S의 끝에 있는 모든 줄 종결자를 제거 할 수 있습니다. 문자열 S가 끝에 빈 줄이 여러 개 붙어 한 줄 이상을 나타내면, 모든 빈 줄의 줄 종결자가 제거됩니다:
>>> lines = ("line 1 \r\n"
... "\r\n"
... "\r\n")
>>> lines.rstrip("\n\r")
'line 1 '
일반적으로 한 번에 한 줄씩 텍스트를 읽을 때만 필요하기 때문에, S.rstrip()을 이런 식으로 사용하면 잘 작동합니다.
scanf() 또는 sscanf() 에 해당하는 것이 있습니까?¶
그런 식으로는 없습니다.
단순한 입력 파싱의 경우, 가장 쉬운 방법은 문자열 객체의 split() 메서드를 사용하여 줄을 공백으로 구분된 단어들로 나누고, int() 또는 float`를 사용하여 십진수 문자열을 숫자 값으로 변환하는 것입니다. :meth:()!split`은 옵션 sep 매개변수를 지원하며, 이는 줄에서 공백이 아닌 다른 것을 구분자로 사용하는 경우 유용합니다.
더 복잡한 입력 파싱의 경우 정규 표현식이 C의 sscanf 보다 더 강력하며 해당 작업에 더 적합합니다.
UnicodeDecodeError 또는 UnicodeEncodeError 에러는 무엇을 의미합니까?¶
유니코드 HOWTO를 참조하십시오.
Raw string(날 문자열)을 홀수 개의 백슬래시로 끝낼 수 있습니까?¶
홀수 개의 백슬래시로 끝나는 raw string은 문자열의 따옴표를 이스케이프합니다:
>>> r'C:\this\will\not\work\'
File "<stdin>", line 1
r'C:\this\will\not\work\'
^
SyntaxError: unterminated string literal (detected at line 1)
이를 해결하기 위한 몇 가지 방법이 있습니다. 하나는 일반 문자열을 사용하고 백슬래시를 두 번 쓰는 것입니다:
>>> 'C:\\this\\will\\work\\'
'C:\\this\\will\\work\\'
다른 하나는 이스케이프된 백슬래시가 포함된 일반 문자열을 raw string에 이어 붙이는 것입니다:
>>> r'C:\this\will\work' '\\'
'C:\\this\\will\\work\\'
Windows 환경에서는 os.path.join() 을 사용하여 백슬래시를 추가하는 것도 가능합니다:
>>> os.path.join(r'C:\this\will\work', '')
'C:\\this\\will\\work\\'
주의할 점은 raw string이 끝나는 위치를 결정할 때는 백슬래시가 따옴표를 “이스케이프” 하지만, raw string의 값을 해석할 때는 이스케이프가 발생하지 않는다는 것입니다. 즉, 백슬래시는 raw string의 값에 그대로 포함됩니다:
>>> r'backslash\'preserved'
"backslash\\'preserved"
또한 language reference 의 사양을 참조하십시오.
성능¶
내 프로그램이 너무 느립니다. 속도를 높이려면 어떻게 해야 합니까?¶
그것은 일반적으로 까다로운 문제입니다. 먼저, 더 깊이 들어가기 전에 기억해야 할 사항 목록입니다:
성능 특성은 파이썬 구현마다 다릅니다. 이 FAQ는 CPython에 중점을 둡니다.
동작은 운영 체제마다 다를 수 있습니다, 특히 I/O 나 다중 스레드에 관해 이야기할 때 그렇습니다.
코드를 최적화하려고 시도하기 전에 프로그램에서 항상 핫스팟을 찾아야 합니다 (
profile모듈을 참조하십시오).벤치마크 스크립트를 작성하면 개선 사항을 탐색할 때 빠르게 반복할 수 있습니다 (
timeit모듈 참조).정교한 최적화에 숨겨진 회귀(regressions)를 잠재적으로 도입하기 전에 (단위 테스트나 기타 기법을 통해) 우수한 코드 커버리지를 갖는 것이 좋습니다.
이것을 전제로, 파이썬 코드 속도를 높이는 많은 트릭이 있습니다. 다음은 수용 가능한 성능 수준에 도달하기 위해 먼 길을 갈 때 도움이 되는 몇 가지 일반적인 원칙입니다:
알고리즘을 더 빠르게 만들면 (또는 더 빠른 알고리즘으로 변경하면) 코드 전체에 미세 최적화 트릭을 뿌리는 것보다 훨씬 큰 이점을 얻을 수 있습니다.
올바른 데이터 구조를 사용하십시오. 내장형과
collections모듈에 대한 설명서를 연구하십시오.표준 라이브러리가 무언가를 하기 위한 프리미티브를 제공할 때, 여러분이 떠올린 다른 대안보다 빠를 가능성이 높습니다 (보장되지는 않습니다). 이것은 내장과 일부 확장형과 같이 C로 작성된 프리미티브의 경우에는 두 배로 그렇습니다. 예를 들어, 정렬하려면
list.sort()내장 메서드나 관련sorted()함수를 사용하십시오 (그리고 약간 고급 사용법의 예는 정렬 기법를 참조하십시오).추상화는 간접(indirections)을 만드는 경향이 있고 인터프리터가 더 많은 일을 하도록 강요합니다. 간접의 수준이 유용한 작업의 양을 초과하면, 프로그램 속도가 느려집니다. 과도한 추상화를 피해야 합니다, 특히 작은 함수나 메서드의 형태에서 그렇습니다 (종종 가독성에도 해롭습니다).
순수 Python으로 허용되는 범위를 넘어선 경우, 이를 더 확장할 수 있는 도구들이 있습니다. 예를 들어, Cython 는 약간 수정된 파이썬 코드를 C 확장 모듈로 컴파일할 수 있으며 여러 플랫폼에서 사용할 수 있습니다. Cython은 컴파일(및 선택적 타입 주석)을 활용하여 여러분의 코드를 인터프리터 방식보다 훨씬 빠르게 만들 수 있습니다. C 프로그래밍 실력에 자신이 있다면, 직접 write a C extension module 를 작성할 수도 있습니다.
더 보기
성능 팁에 할당된 위키 페이지.
많은 문자열을 함께 이어붙이는 가장 효율적인 방법은 무엇입니까?¶
str과 bytes 객체는 불변이므로, 많은 문자열을 함께 이어붙이면 각 이어붙이기가 새 객체를 생성하기 때문에 비효율적입니다. 일반적일 때, 총 실행 시간 비용은 전체 문자열 길이의 제곱에 비례합니다.
많은 str 객체를 누적하기 위해, 권장되는 관용구는 객체를 리스트에 배치하고 마지막에 str.join()을 호출하는 것입니다:
chunks = []
for s in my_strings:
chunks.append(s)
result = ''.join(chunks)
(또 다른 합리적으로 효율적인 관용구는 io.StringIO 를 사용하는 것입니다.)
많은 bytes 객체를 누적하기 위해, 권장되는 관용구는 제자리 이어붙이기(+= 연산자)을 사용하여 bytearray 객체를 확장하는 것입니다:
result = bytearray()
for b in my_bytes_objects:
result += b
시퀀스 (튜플/리스트)¶
튜플과 리스트를 어떻게 변환합니까?¶
형 생성자 tuple(seq)는 임의의 시퀀스(실제로는, 모든 이터러블)를 같은 순서로 같은 항목을 가진 튜플로 변환합니다.
예를 들어, tuple([1, 2, 3])은 (1, 2, 3)을 산출하고 tuple('abc')는 ('a', 'b', 'c')를 산출합니다. 인자가 튜플이면 사본을 만들지 않고 같은 객체를 반환하므로, 객체가 이미 튜플인지 확실하지 않을 때 tuple()을 호출하는 것이 저렴합니다.
형 생성자 list(seq)는 임의의 시퀀스나 이터러블을 같은 순서로 같은 항목이 있는 리스트로 변환합니다. 예를 들어, list((1, 2, 3))은 [1, 2, 3]을 산출하고 list('abc')는 ['a', 'b', 'c']를 산출합니다. 인자가 리스트이면, seq[:]와 같이 사본을 만듭니다.
음수 인덱스는 무엇입니까?¶
파이썬 시퀀스는 양수와 음수로 인덱싱됩니다. 양수의 경우 0은 첫 번째 인덱스이고 1은 두 번째 인덱스이고 이런 식으로 계속됩니다. 음수 인덱스의 경우 -1은 마지막 인덱스이고 -2는 끝에서 두 번째 인덱스이고 이런 식으로 계속됩니다. seq[-n]을 seq[len(seq)-n]과 같다고 생각하십시오.
음수 인덱스를 사용하면 매우 편리할 수 있습니다. 예를 들어 S[:-1]은 마지막 문자를 제외한 문자열의 모든 것인데, 문자열에서 후행 줄 바꿈을 제거하는 데 유용합니다.
시퀀스를 역순으로 이터레이트 하려면 어떻게 합니까?¶
reversed() 내장 함수를 사용하십시오:
for x in reversed(sequence):
... # do something with x ...
이것은 원본 시퀀스에는 영향을 미치지 않지만, 이터레이트 할 뒤집힌 순서의 새 사본을 만듭니다.
리스트에서 중복을 어떻게 제거합니까?¶
이 작업을 수행하는 여러 가지 방법에 대한 긴 논의는 파이썬 요리책을 참조하십시오:
리스트 순서를 바꿔도 상관없다면, 리스트를 정렬한 다음 리스트 끝에서 스캔하면서 중복 항목을 삭제하십시오:
if mylist:
mylist.sort()
last = mylist[-1]
for i in range(len(mylist)-2, -1, -1):
if last == mylist[i]:
del mylist[i]
else:
last = mylist[i]
리스트의 모든 요소를 집합 키로 사용할 수 있는 경우(즉, 모두 hashable 인 경우) 이 방법이 종종 더 빠릅니다:
mylist = list(set(mylist))
이것은 리스트를 집합으로 변환하여, 중복을 제거한 다음, 리스트로 되돌립니다.
리스트에서 여러 항목을 어떻게 제거합니까?¶
중복을 제거할 때와 마찬가지로, 삭제 조건을 사용하여 명시적으로 역순으로 이터레이션 하는 것이 한 가지 방법입니다. 그러나, 묵시적 또는 명시적 순방향 이터레이션을 사용하며 슬라이스 치환을 사용하는 것이 더 쉽고 빠릅니다. 여기 세 가지 변형이 있습니다:
mylist[:] = filter(keep_function, mylist)
mylist[:] = (x for x in mylist if keep_condition)
mylist[:] = [x for x in mylist if keep_condition]
리스트 컴프리헨션이 아마 가장 빠릅니다.
파이썬에서 어떻게 배열을 만드나요?¶
리스트를 사용하십시오:
["this", 1, "is", "an", "array"]
리스트는 시간 복잡성 면에서 C나 파스칼(Pascal) 배열과 동등합니다; 가장 큰 차이점은 파이썬 리스트에 다양한 형의 객체가 포함될 수 있다는 것입니다.
array 모듈은 또한 콤팩트한 표현을 가진 고정된 타입의 배열을 생성하는 메서드를 제공하지만, 리스트보다 인덱싱이 느립니다. 또한 NumPy 및 기타 타사 패키지도 다양한 특성을 가진 배열 형태(array-like) 구조를 정의한다는 점에 유의하십시오.
Lisp 스타일의 연결 리스트를 얻으려면 튜플을 사용하여 cons cell 을 모방할 수 있습니다:
lisp_list = ("like", ("this", ("example", None) ) )
가변성이 필요한 경우 튜플 대신 리스트를 사용할 수 있습니다. 여기서 Lisp car 의 대응물은 lisp_list[0] 이고, cdr 의 대응물은 lisp_list[1] 입니다. 이 방법이 파이썬 리스트를 사용하는 것보다 훨씬 느리기 때문에 정말로 필요한 경우가 아니라면 사용하지 마십시오.
다차원 리스트를 어떻게 만듭니까?¶
다음과 같이 다차원 배열을 만들려고 했을 것입니다:
>>> A = [[None] * 2] * 3
인쇄하면 올바르게 보입니다:
>>> A
[[None, None], [None, None], [None, None]]
그러나 값을 대입하면, 여러 위치에 나타납니다:
>>> A[0][0] = 5
>>> A
[[5, None], [5, None], [5, None]]
그 이유는 *로 리스트를 복제해도 복사본을 만들지 않고 기존 객체에 대한 참조만 만들기 때문입니다. *3은 길이 2의 같은 리스트에 대한 3개의 참조를 포함하는 리스트를 만듭니다. 한 행에 대한 변경 사항은 모든 행에 나타나는데, 거의 확실히 여러분이 원하는 것은 아닙니다.
제안된 방법은 원하는 길이의 리스트를 먼저 만든 다음 새로 만든 리스트로 각 요소를 채우는 것입니다:
A = [None] * 3
for i in range(3):
A[i] = [None] * 2
그러면 길이가 2인 3개의 다른 리스트를 포함하는 리스트가 생성됩니다. 리스트 컴프리헨션도 사용할 수 있습니다:
w, h = 2, 3
A = [[None] * w for i in range(h)]
또는 매트릭스 데이터 타입을 제공하는 확장 모듈을 사용할 수 있습니다. NumPy 가 가장 잘 알려져 있습니다.
객체 시퀀스에 메서드나 함수를 어떻게 적용합니까?¶
메서드 또는 함수를 호출하고 그 결과값을 리스트에 모으려면 list comprehension 이 세련된 해결책입니다:
result = [obj.method() for obj in mylist]
result = [function(obj) for obj in mylist]
결과 값을 저장하지 않고 메서드나 함수만 실행하려면 일반적인 for 루프면 충분합니다:
for obj in mylist:
obj.method()
for obj in mylist:
function(obj)
덧셈은 작동하는데, 왜 a_tuple[i] += [‘item’]이 예외를 일으킵니까?¶
이는 증분 대입 연산자가 대입 연산자라는 사실과 파이썬에서 가변 객체와 불변 객체의 차이점이 결합하기 때문입니다.
이 논의는 증분 대입 연산자가 가변 객체를 가리키는 튜플의 요소에 적용될 때 일반적으로 적용되지만, 우리는 list와 +=를 예제로 사용합니다.
다음과 같이 작성한다면:
>>> a_tuple = (1, 2)
>>> a_tuple[0] += 1
Traceback (most recent call last):
...
TypeError: 'tuple' object does not support item assignment
예외의 이유는 명확합니다: 1이 a_tuple[0]이 가리키는 객체(1)에 더해져서, 결과 객체 2를 생성하지만, 계산 결과 2를 튜플의 요소 0에 대입하려고 하면, 튜플의 요소가 가리키는 것을 변경할 수 없기 때문에 에러가 발생합니다.
수면 아래에서, 이 증분 대입문이 하는 일은 대략 다음과 같습니다:
>>> result = a_tuple[0] + 1
>>> a_tuple[0] = result
Traceback (most recent call last):
...
TypeError: 'tuple' object does not support item assignment
튜플은 불변이므로, 연산의 대입 부분이 에러를 발생시킵니다.
다음과 같이 작성하면:
>>> a_tuple = (['foo'], 'bar')
>>> a_tuple[0] += ['item']
Traceback (most recent call last):
...
TypeError: 'tuple' object does not support item assignment
예외는 조금 더 놀랍습니다, 더 놀라운 것은 에러가 있었지만 더하기가 동작했다는 사실입니다:
>>> a_tuple[0]
['foo', 'item']
이런 현상이 발생하는 이유를 이해하려면 다음을 알아야 합니다. (a) 객체가 __iadd__() 매직 메서드를 구현하는 경우, += 증분 대입이 실행될 때 이 메서드가 호출되며 그 결과 값이 대입 문에서 사용됩니다. (b) 리스트의 경우, __iadd__() 는 리스트에 대해 extend() 를 호출하고 해당 리스트를 반환하는 것과 동일합니다. 이것이 우리가 리스트에 대해 += 가 list.extend() 의 “단축형”이라고 말하는 이유입니다:
>>> a_list = []
>>> a_list += [1]
>>> a_list
[1]
이것은 다음과 동등합니다:
>>> result = a_list.__iadd__([1])
>>> a_list = result
a_list가 가리키는 객체가 변경되었고, 변경된 객체에 대한 포인터가 다시 a_list에 대입됩니다. 대입의 최종 결과는 no-op인데, a_list가 이전에 가리키고 있던 것과 같은 객체에 대한 포인터이기 때문입니다, 하지만 대입은 여전히 일어납니다.
따라서, 우리의 튜플 예제에서 일어나는 일은 다음과 동등합니다:
>>> result = a_tuple[0].__iadd__(['item'])
>>> a_tuple[0] = result
Traceback (most recent call last):
...
TypeError: 'tuple' object does not support item assignment
__iadd__() 는 성공하고 따라서 리스트는 확장되지만, result 가 a_tuple[0] 이 가리키는 것과 동일한 객체를 가리키고 있더라도 최종 대입은 오류를 발생시킵니다. 튜플은 불변이기 때문입니다.
복잡한 정렬을 하고 싶습니다: 파이썬에서 Schwartzian 변환을 할 수 있습니까?¶
Perl 커뮤니티의 Randal Schwartz에 의한 이 기법은 리스트의 각 요소를 각 요소를 “정렬 값”에 매핑하는 메트릭으로 정렬합니다. 파이썬에서는, list.sort() 메서드의 key 인자를 사용하십시오:
Isorted = L[:]
Isorted.sort(key=lambda s: int(s[10:15]))
한 리스트를 다른 리스트의 값으로 정렬하려면 어떻게 해야 합니까?¶
그것들을 튜플의 이터레이터로 병합하고, 결과 리스트를 정렬한 다음, 원하는 요소를 선택하십시오.
>>> list1 = ["what", "I'm", "sorting", "by"]
>>> list2 = ["something", "else", "to", "sort"]
>>> pairs = zip(list1, list2)
>>> pairs = sorted(pairs)
>>> pairs
[("I'm", 'else'), ('by', 'sort'), ('sorting', 'to'), ('what', 'something')]
>>> result = [x[1] for x in pairs]
>>> result
['else', 'sort', 'to', 'something']
객체¶
클래스는 무엇입니까?¶
클래스는 class 문을 실행하여 만든 특정 객체 형입니다. 클래스 객체는 인스턴스 객체를 만들기 위한 주형으로 사용되며, 데이터형과 관련된 데이터(어트리뷰트)와 코드(메서드)를 모두 내장합니다.
클래스는 베이스 클래스라고 하는 하나 이상의 다른 클래스를 기반으로 할 수 있습니다. 그러면 베이스 클래스의 어트리뷰트와 메서드를 상속합니다. 이는 상속을 통해 객체 모델을 점진적으로 재정의할 수 있도록 합니다. 우편함에 대한 기본 접근자 메서드를 제공하는 일반 Mailbox 클래스와 다양한 특정 사서함 형식을 처리하는 MboxMailbox, MaildirMailbox, OutlookMailbox와 같은 서브 클래스가 있을 수 있습니다.
메서드는 무엇입니까?¶
메서드는 일반적으로 x.name(arguments...)로 호출하는 어떤 객체 x의 함수입니다. 메서드는 클래스 정의 내에서 함수로 정의됩니다:
class C:
def meth(self, arg):
return arg * 2 + self.attribute
self는 무엇입니까?¶
self는 단지 메서드의 첫 번째 인자를 위한 관례적 이름입니다. meth(self, a, b, c)로 정의된 메서드는 정의가 등장한 클래스의 어떤 인스턴스 x에 대해 x.meth(a, b, c)로 호출되어야 합니다; 호출된 메서드는 meth(x, a, b, c)처럼 호출되었다고 생각합니다.
객체가 주어진 클래스나 그 서브 클래스의 인스턴스인지 어떻게 확인합니까?¶
내장 함수 isinstance(obj, cls) <isinstance>`를 사용하십시오. 단일 클래스 대신 튜플을 제공함으로써 객체가 여러 클래스 중 어느 하나라도 인스턴스인지 확인할 수 있습니다. 예를 들어, ``isinstance(obj, (class1, class2, ...))``와 같이 사용할 수 있으며, 파이썬 내장 타입 중 하나인지도 확인할 수 있습니다. 예: ``isinstance(obj, str)`() 또는 isinstance(obj, (int, float, complex)).
isinstance() 는 또한 abstract base class 로부터의 가상 상속도 확인한다는 점에 유의하십시오. 따라서 등록된 클래스의 경우 직접 또는 간접적으로 상속받지 않았더라도 테스트 결과가 True 로 반환됩니다. “실제 상속”을 확인하려면 클래스의 method resolution order (MRO)를 검사하십시오.
from collections.abc import Mapping
class P:
pass
class C(P):
pass
Mapping.register(P)
>>> c = C()
>>> isinstance(c, C) # direct
True
>>> isinstance(c, P) # indirect
True
>>> isinstance(c, Mapping) # virtual
True
# Actual inheritance chain
>>> type(c).__mro__
(<class 'C'>, <class 'P'>, <class 'object'>)
# Test for "true inheritance"
>>> Mapping in type(c).__mro__
False
대부분의 프로그램은 사용자 정의 클래스에서 isinstance()를 자주 사용하지 않음에 유의하십시오. 클래스를 직접 개발하고 있다면, 더 적절한 객체 지향 스타일은 객체의 클래스를 확인하고 클래스에 따라 다른 작업을 수행하는 대신 특정 동작을 캡슐화하는 클래스의 메서드를 정의하는 것입니다. 예를 들어, 무언가를 수행하는 함수가 있다면:
def search(obj):
if isinstance(obj, Mailbox):
... # code to search a mailbox
elif isinstance(obj, Document):
... # code to search a document
elif ...
더 나은 접근법은 모든 클래스에서 search() 메서드를 정의하고 단지 그것을 호출하는 것입니다:
class Mailbox:
def search(self):
... # code to search a mailbox
class Document:
def search(self):
... # code to search a document
obj.search()
위임이란 무엇입니까?¶
위임(Delegation)은 객체 지향 기법(디자인 패턴이라고도 함)입니다. 만약 당신이 어떤 객체 x 를 가지고 있고, 그 메서드 중 하나만 행동을 바꾸고 싶다고 가정해 봅시다. 당신은 관심 있는 메서드의 새로운 구현을 제공하고 나머지 모든 메서드를 x 의 해당 메서드로 위임하는 새로운 클래스를 생성할 수 있습니다.
파이썬 프로그래머는 쉽게 위임을 구현할 수 있습니다. 예를 들어, 다음 클래스는 파일처럼 동작하지만, 기록되는 모든 데이터를 대문자로 변환하는 클래스를 구현합니다:
class UpperOut:
def __init__(self, outfile):
self._outfile = outfile
def write(self, s):
self._outfile.write(s.upper())
def __getattr__(self, name):
return getattr(self._outfile, name)
여기서 UpperOut 클래스는 인자 문자열을 대문자로 변환한 뒤 기반이 되는 self._outfile.write() 메서드를 호출하도록 write() 메서드를 재정의합니다. 다른 모든 메서드는 기본 객체인 self._outfile 에 위임됩니다. 이 위임은 __getattr__() 메서드를 통해 수행되며, 어트리뷰트 접근 제어에 대한 자세한 내용은 the language reference 를 참조하십시오.
더 일반적인 경우에 위임이 더 복잡해질 수 있음에 주의하십시오. 어트리뷰트를 읽는 것뿐만 아니라 설정(set)해야 하는 경우, 해당 클래스는 __setattr__() 메서드도 정의해야 하며 이를 신중하게 처리해야 합니다. __setattr__() 의 기본 구현은 대략 다음과 같습니다:
class X:
...
def __setattr__(self, name, value):
self.__dict__[name] = value
...
많은 __setattr__() 구현체는 무한 재귀를 발생시키지 않고 self에 어트리뷰트를 설정하기 위해 object.__setattr__() 을 호출합니다:
class X:
def __setattr__(self, name, value):
# Custom logic here...
object.__setattr__(self, name, value)
대신에, self.__dict__ 에 항목을 직접 삽입하여 어트리뷰트를 설정하는 것도 가능합니다.
부모 클래스에서 정의된 메서드를 이를 확장하는 파생 클래스에서 어떻게 호출합니까?¶
내장 super() 함수를 사용하십시오:
class Derived(Base):
def meth(self):
super().meth() # calls Base.meth
이 예제에서 super() 는 호출된 인스턴스(self 값)를 자동으로 결정하고, type(self).__mro__ 를 통해 method resolution order (MRO)를 조회하며, MRO에서 Derived 다음에 위치한 Base 를 반환합니다.
베이스 클래스를 쉽게 변경할 수 있도록 코드를 구성하려면 어떻게 해야 합니까?¶
부모 클래스를 별칭(alias)으로 할당하고 그 별칭으로부터 파생될 수도 있습니다. 그러면 변경해야 하는 것은 별칭에 할당된 값뿐입니다. 참고로, 이 기법은 어떤 부모 클래스를 사용할지 동적으로 결정해야 하는 경우(예: 리소스 가용성에 따라 결정)에도 유용합니다. 예:
class Base:
...
BaseAlias = Base
class Derived(BaseAlias):
...
정적 클래스 데이터와 정적 클래스 메서드를 만들려면 어떻게 해야 합니까?¶
(C++나 Java의 의미에서) 정적 데이터와 정적 메서드 모두 파이썬에서 지원됩니다.
정적 데이터의 경우, 단순히 클래스 어트리뷰트를 정의하십시오. 어트리뷰트에 새 값을 대입하려면, 대입에서 클래스 이름을 명시적으로 사용해야 합니다:
class C:
count = 0 # number of times C.__init__ called
def __init__(self):
C.count = C.count + 1
def getcount(self):
return C.count # or return self.count
c 자체나 c.__class__에서 C로 돌아가는 베이스 클래스 검색 경로에 놓인 일부 클래스에 의해 재정의되지 않는 한, c.count는 isinstance(c, C)가 성립하는 모든 c에 대해 C.count를 참조합니다.
주의: C의 메서드 내에서, self.count = 42와 같은 대입은 self의 자체 딕셔너리에 “count”라는 새롭고 관련이 없는 인스턴스를 만듭니다. 클래스 정적 데이터 이름의 재연결은 항상 메서드 내부에 있는지에 관계없이 클래스를 지정해야 합니다:
C.count = 314
정적 메서드도 가능합니다:
class C:
@staticmethod
def static(arg1, arg2, arg3):
# No 'self' parameter!
...
그러나, 정적 메서드의 효과를 얻는 훨씬 간단한 방법은 단순한 모듈 수준 함수를 사용하는 것입니다:
def getcount():
return C.count
여러분의 코드가 모듈 당 하나의 클래스 (또는 밀접하게 관련된 클래스 계층 구조)를 정의하도록 구조화되었다면, 이것이 원하는 캡슐화를 제공합니다.
파이썬에서 생성자(또는 메서드)를 어떻게 재정의할 수 있습니까?¶
이 답변은 실제로 모든 메서드에 적용되지만, 질문은 일반적으로 생성자 문맥에서 가장 먼저 나옵니다.
C++에서는 다음과 같이 작성합니다:
class C {
C() { cout << "No arguments\n"; }
C(int i) { cout << "Argument is " << i << "\n"; }
}
파이썬에서는 기본 인자를 사용하여 모든 경우를 다루는 단일 생성자를 작성해야 합니다. 예를 들면:
class C:
def __init__(self, i=None):
if i is None:
print("No arguments")
else:
print("Argument is", i)
이것은 완전히 동등하지는 않지만, 실제로는 아주 가깝습니다.
또한 가변 길이 인자 목록을 시도해 볼 수도 있습니다. 예:
def __init__(self, *args):
...
같은 접근법이 모든 메서드 정의에서도 동작합니다.
__spam을 사용하려고 하는데 _SomeClassName__spam에 대한 에러가 발생합니다.¶
이중 선행 밑줄이 있는 변수 이름은 클래스 비공개(private) 변수를 정의하는 간단하지만, 효과적인 방법을 제공하기 위해 “뒤섞입니다(mangled)”. __spam 형식(적어도 두 개의 선행 밑줄, 최대 하나의 후행 밑줄)의 모든 식별자는 _classname__spam으로 텍스트 대체되는데, 여기서 classname 은 모든 선행 밑줄이 제거된 현재 클래스 이름입니다.
식별자는 클래스 내부에서 그대로 사용할 수 있지만, 클래스 외부에서 접근하려면 변형된(mangled) 이름을 사용해야 합니다:
class A:
def __one(self):
return 1
def two(self):
return 2 * self.__one()
class B(A):
def three(self):
return 3 * self._A__one()
four = 4 * A()._A__one()
특히 이것이 개인정보를 보장하는 것은 아닙니다. 외부 사용자가 의도적으로 비공개 어트리뷰트에 접근할 수 있기 때문입니다. 많은 파이썬 프로그래머들은 비공개 변수 이름을 사용하는 데 신경을 쓰지 않기도 합니다.
더 보기
자세한 내용 및 특수한 경우는 private name mangling specifications 를 참조하십시오.
내 클래스는 __del__을 정의하지만 객체를 삭제할 때 호출되지 않습니다.¶
몇 가지 가능한 이유가 있습니다.
del 문이 반드시 이는 단순히 객체의 참조 횟수를 줄이는 것이며, 이 횟수가 0이 되면 :meth:()!__del__`이 호출됩니다.
데이터 구조에 순환 링크가 포함된 경우(예: 각 자식은 부모 참조를 가지고 있고 각 부모는 자식 목록을 가진 트리), 참조 횟수가 결코 0으로 돌아가지 않습니다. 파이썬은 가끔 이러한 사이클을 감지하기 위해 알고리즘을 실행하지만, 가비지 컬렉터가 데이터 구조에 대한 마지막 참조가 사라진 후 한참 뒤에 실행될 수 있으므로, 귀하의 __del__() 메서드가 불편하고 무작위적인 시점에 호출될 수 있습니다. 이는 문제를 재현하려고 할 때 불편을 초래합니다. 더 나쁘게는, 객체의 __del__() 메서드가 실행되는 순서도 임의적입니다. gc.collect() 를 실행하여 강제로 가비지 컬렉션을 수행할 수도 있지만, 어떤 경우에는 객체가 절대 수거되지 않는 특수한 경우도 존재합니다.
사이클 수집기(cycle collector)가 있더라도, 사용이 끝날 때마다 호출되는 명시적인 close() 메서드를 객체에 정의하는 것이 좋습니다. close() 메서드는 하위 객체를 참조하는 어트리뷰트를 제거할 수 있습니다. __del__() 을 직접 호출하지 마십시오. __del__() 은 close() 를 호출해야 하며, close() 는 동일한 객체에 대해 여러 번 호출되어도 안전하도록 보장해야 합니다.
순환 참조를 피하는 또 다른 방법은 weakref 모듈을 사용하는 것입니다. 이 모듈은 참조 횟수를 늘리지 않고 객체를 가리킬 수 있도록 합니다. 예를 들어, 트리 자료 구조는 부모와 형제 참조에 대해 약한 참조를 사용해야 합니다 (이런 것들이 필요하다면!).
마지막으로, 만약 귀하의 __del__() 메서드가 예외를 발생시키면 경고 메시지가 sys.stderr 에 출력됩니다.
주어진 클래스의 모든 인스턴스 목록을 어떻게 얻습니까?¶
파이썬은 클래스(또는 내장형)의 모든 인스턴스를 추적하지 않습니다. 클래스 생성자가 각 인스턴스에 대한 약한 참조 리스트를 유지하여 모든 인스턴스를 추적하도록 프로그래밍 할 수 있습니다.
id()의 결과가 고유하지 않은 것처럼 보이는 이유는 무엇입니까?¶
id() 내장은 객체 수명 동안 고유하도록 보장되는 정수를 반환합니다. CPython에서는 이것이 객체의 메모리 주소이므로, 객체가 메모리에서 삭제된 후 새로 만들어진 다음 객체가 메모리의 같은 위치에 할당되는 경우가 자주 발생합니다. 다음과 같이 예시할 수 있습니다:
>>> id(1000)
13901272
>>> id(2000)
13901272
두 개의 id는 다른 정수 객체에 속하는데, id() 호출 실행 앞에 만들어지고, 호출 직후 삭제됩니다. id를 검사하려는 객체가 여전히 살아 있도록 하려면, 그 객체에 대한 다른 참조를 만드십시오:
>>> a = 1000; b = 2000
>>> id(a)
13901272
>>> id(b)
13891296
is 연산자를 사용한 아이덴티티 검사는 언제 신뢰할 수 있습니까?¶
is 연산자는 객체 아이덴티티를 검사합니다. 검사 a is b는 id(a) == id(b)와 동등합니다.
아이덴티티 검사의 가장 중요한 속성은 객체가 항상 자신과 동일하고 a is a는 항상 True를 반환한다는 것입니다. 아이덴티티 검사는 일반적으로 동등성 검사보다 빠릅니다. 동등성 검사와 달리, 아이덴티티 테스트는 불리언 True나 False를 반환함이 보장됩니다.
그러나, 객체 아이덴티티가 보장될 때 아이덴티티 검사가 동등성 검사를 대체할 수 있습니다. 일반적으로, 아이덴티티가 보장되는 세 가지 상황이 있습니다:
대입은 새로운 이름을 생성하지만 객체의 아이덴티티(identity)를 변경하지는 않습니다.
new = old대입 후,new is old임이 보장됩니다.객체 참조를 저장하는 컨테이너에 객체를 넣는 것은 객체의 아이덴티티를 변화시키지 않습니다. 리스트 할당
s[0] = x이후,s[0] is x임이 보장됩니다.객체가 싱글톤인 경우, 해당 객체의 인스턴스가 단 하나만 존재함을 의미합니다.
a = None및b = None할당 후,None은 싱글톤이므로a is b임이 보장됩니다.
대부분의 다른 상황에서는 아이덴티티 검사가 권장되지 않으며 동등성 테스트가 선호됩니다. 특히, 싱글톤이 보장되지 않는 int와 str과 같은 상수를 확인하는 데 아이덴티티 검사를 사용해서는 안 됩니다:
>>> a = 10_000_000
>>> b = 5_000_000
>>> c = b + 5_000_000
>>> a is c
False
>>> a = 'Python'
>>> b = 'Py'
>>> c = b + 'thon'
>>> a is c
False
마찬가지로, 가변 컨테이너의 새 인스턴스는 절대 동일하지 않습니다:
>>> a = []
>>> b = []
>>> a is b
False
표준 라이브러리 코드에서, 아이덴티티 검사를 올바르게 사용하는 몇 가지 일반적인 패턴을 볼 수 있습니다:
PEP 8 에서 권장하듯이,
None을 확인하는 가장 좋은 방법은 아이덴티티 테스트입니다. 이는 코드 내에서 평범한 영어처럼 읽히며, 불리언 값이 false로 평가되는 다른 객체들과 혼동되는 것을 방지합니다.None이 유효한 입력 값인 경우 옵션 인자를 감지하는 것이 까다로울 수 있습니다. 이러한 상황에서는 다른 객체와 확실히 구분되는 싱글톤 센티널(sentinel) 객체를 생성할 수 있습니다. 예를 들어, 다음은dict.pop()과 유사하게 작동하는 메서드를 구현하는 방법입니다:_sentinel = sentinel('_sentinel') def pop(self, key, default=_sentinel): if key in self: value = self[key] del self[key] return value if default is _sentinel: raise KeyError(key) return default
컨테이너 구현체는 때때로 동일성 테스트를 결합하여 동등성(equality) 검사를 보완해야 합니다. 이를 통해 자신과 같지 않은
float('NaN')같은 객체들로 인해 코드가 혼동되는 것을 방지합니다.
예를 들어, 다음은 collections.abc.Sequence.__contains__() 의 구현입니다:
def __contains__(self, value):
for v in self:
if v is value or v == value:
return True
return False
서브 클래스가 불변 인스턴스에 어떤 데이터가 저장되는지 제어하려면 어떻게 해야 합니까?¶
불변 유형을 서브 클래스로 만들 때는 __init__() 메서드 대신 __new__() 메서드를 재정의하십시오. 후자는 인스턴스가 생성된 후에 실행되므로, 불변 인스턴스의 데이터를 변경하기에는 너무 늦습니다.
이 모든 불변 클래스는 부모 클래스와 다른 시그니처를 가집니다:
import datetime as dt
class FirstOfMonthDate(dt.date):
"Always choose the first day of the month"
def __new__(cls, year, month, day):
return super().__new__(cls, year, month, 1)
class NamedInt(int):
"Allow text names for some numbers"
xlat = {'zero': 0, 'one': 1, 'ten': 10}
def __new__(cls, value):
value = cls.xlat.get(value, value)
return super().__new__(cls, value)
class TitleStr(str):
"Convert str to name suitable for a URL path"
def __new__(cls, s):
s = s.lower().replace(' ', '-')
s = ''.join([c for c in s if c.isalnum() or c == '-'])
return super().__new__(cls, s)
이 클래스들은 다음과 같이 사용할 수 있습니다:
>>> FirstOfMonthDate(2012, 2, 14)
FirstOfMonthDate(2012, 2, 1)
>>> NamedInt('ten')
10
>>> NamedInt(20)
20
>>> TitleStr('Blog: Why Python Rocks')
'blog-why-python-rocks'
메서드 호출을 캐싱하려면 어떻게 해야 합니까?¶
메서드를 캐싱하는 두 가지 주요 도구는 @functools.cached_property 와 @functools.lru_cache 입니다. 전자는 인스턴스 수준에서 결과를 저장하고, 후자는 클래스 수준에서 저장합니다.
cached_property 방식은 인자가 없는 메서드에만 작동합니다. 이 방식은 인스턴스에 대한 참조를 생성하지 않습니다. 캐시된 메서드 결과는 인스턴스가 살아있는 동안에만 유지됩니다.
장점은 인스턴스가 더 이상 사용되지 않을 때 캐시된 메서드 결과가 즉시 해제된다는 것입니다. 단점은 인스턴스가 쌓이면 누적된 메서드 결과도 함께 쌓이게 되며, 이는 제한 없이 커질 수 있다는 점입니다.
lru_cache 방식은 hashable 한 인자를 가진 메서드에서 작동합니다. 이 방식은 약한 참조(weak reference)를 전달하기 위한 특별한 노력이 없는 한, 인스턴스에 대한 참조를 생성합니다.
최근 최소 사용(least recently used) 알고리즘의 장점은 캐시가 지정된 maxsize 로 제한된다는 것입니다. 단점은 인스턴스가 캐시에서 밀려나거나 캐시가 비워질 때까지 살아있는 상태로 유지된다는 것입니다.
이 예제는 다양한 기법을 보여줍니다:
class Weather:
"Lookup weather information on a government website"
def __init__(self, station_id):
self._station_id = station_id
# The _station_id is private and immutable
def current_temperature(self):
"Latest hourly observation"
# Do not cache this because old results
# can be out of date.
@cached_property
def location(self):
"Return the longitude/latitude coordinates of the station"
# Result only depends on the station_id
@lru_cache(maxsize=20)
def historic_rainfall(self, date, units='mm'):
"Rainfall on a given date"
# Depends on the station_id, date, and units.
위의 예제는 station_id 가 절대 변경되지 않는다고 가정합니다. 관련 인스턴스 속성이 가변적이라면, cached_property 방식은 속성의 변화를 감지할 수 없기 때문에 작동하지 않습니다.
station_id 가 가변적일 때 lru_cache 방식을 작동하게 하려면, 캐시가 관련 속성 업데이트를 감지할 수 있도록 클래스가 __eq__() 와 __hash__() 메서드를 정의해야 합니다:
class Weather:
"가변적인 관측소 식별자를 사용한 예제"
def __init__(self, station_id):
self.station_id = station_id
def change_station(self, station_id):
self.station_id = station_id
def __eq__(self, other):
return self.station_id == other.station_id
def __hash__(self):
return hash(self.station_id)
@lru_cache(maxsize=20)
def historic_rainfall(self, date, units='cm'):
'특정 날짜의 강수량'
# station_id, date, 그리고 units에 의존합니다.
모듈¶
.pyc 파일을 어떻게 만듭니까?¶
모듈이 처음 임포트 될 때 (또는 현재 컴파일된 파일이 만들어진 후 소스 파일이 변경되었을 때) 컴파일된 코드를 포함하는 .pyc 파일은 .py 파일을 포함하는 디렉터리의 __pycache__ 서브 디렉터리에 만들어져야 합니다. .pyc 파일은 .py 파일과 같은 이름으로 시작하고, .pyc로 끝나며, 파일을 만든 특정 python 바이너리 파일에 종속되는 중간 구성 요소를 갖는 파일명을 갖습니다. (자세한 내용은 PEP 3147을 참조하십시오.)
.pyc 파일이 만들어지지 않을 수 있는 한 가지 이유는 소스 파일이 포함된 디렉터리의 권한 문제입니다. 즉, __pycache__ 서브 디렉터리를 만들 수 없다는 뜻입니다. 예를 들어, 한 사용자로 개발했지만 다른 사용자로 실행하는 경우에 이런 일이 일어날 수 있습니다, 가령 웹 서버로 테스트하고 있을 때입니다.
PYTHONDONTWRITEBYTECODE 환경 변수가 설정되어 있지 않은 경우, 모듈을 임포트할 때 파이썬이 __pycache__ 서브 디렉터리를 생성하고 컴파일된 모듈을 해당 디렉터리에 쓸 수 있는 권한과 여유 공간 등의 조건이 충족되면 .pyc 파일이 자동으로 생성됩니다.
최상위 스크립트에서 파이썬을 실행하는 것은 임포트로 간주되지 않으며 .pyc 파일이 생성되지 않습니다. 예를 들어, 다른 모듈 xyz.py``를 임포트하는 최상위 모듈 ``foo.py``가 있을 때, (셸 명령으로 ``python foo.py``를 입력하여) ``foo``를 실행하면 ``xyz``는 임포트되므로 ``xyz``에 대한 ``.pyc 파일이 생성되지만, foo.py``는 임포트되는 것이 아니므로 ``foo``에 대해서는 ``.pyc 파일이 생성되지 않습니다.
foo에 대한 .pyc 파일을 만들 필요가 있으면 – 즉, 임포트 되지 않는 모듈에 대한 .pyc 파일을 만들려면 – py_compile과 compileall 모듈을 사용할 수 있습니다.
py_compile 모듈은 임의의 모듈을 수동으로 컴파일할 수 있습니다. 한 가지 방법은 해당 모듈에서 compile() 함수를 대화식으로 사용하는 것입니다:
>>> import py_compile
>>> py_compile.compile('foo.py')
이 작업은 .pyc 를 foo.py 와 동일한 위치의 __pycache__ 서브 디렉터리에 기록합니다(또는 선택적 매개변수 cfile 로 이를 재정의할 수 있습니다).
compileall 모듈을 사용하여 디렉터리의 모든 파일을 자동으로 컴파일할 수도 있습니다. compileall.py를 실행하고 컴파일할 파이썬 파일이 포함된 디렉터리의 경로를 제공하여 셸 프롬프트에서 이를 수행할 수 있습니다:
python -m compileall .
현재 모듈 이름을 어떻게 찾습니까?¶
모듈은 사전 정의된 전역 변수 __name__을 봄으로써 모듈 자신의 이름을 찾을 수 있습니다. 값이 '__main__'이면, 프로그램이 스크립트로 실행 중입니다. 일반적으로 모듈을 임포트 해서 사용하는 많은 모듈은 명령 줄 인터페이스나 자체 테스트를 제공하며, __name__을 확인한 후에 만 이 코드를 실행합니다:
def main():
print('Running test...')
...
if __name__ == '__main__':
main()
서로 임포트 하는 모듈을 어떻게 만들 수 있습니까?¶
다음 모듈이 있다고 가정하십시오:
foo.py:
from bar import bar_var
foo_var = 1
bar.py:
from foo import foo_var
bar_var = 2
문제는 인터프리터가 다음 단계를 수행한다는 것입니다:
main이
foo를 임포트합니다.foo를 위한 빈 전역 변수가 생성됩니다.foo가 컴파일되고 실행을 시작합니다.foo가bar를 임포트합니다.bar를 위한 빈 전역 변수가 생성됩니다.bar가 컴파일되고 실행을 시작합니다.bar이foo를 임포트합니다(이미foo라는 이름의 모듈이 존재하므로 아무 작업도 수행하지 않습니다).임포트 메커니즘이
bar.foo_var = foo.foo_var를 설정하기 위해foo전역 변수에서foo_var를 읽으려고 시도합니다.
마지막 단계가 실패합니다. 파이썬이 아직 foo를 인터프리트 하는 것을 완료하지 않았고 foo의 전역 기호 딕셔너리가 여전히 비어 있기 때문입니다.
import foo를 사용하고 전역 코드에서 foo.foo_var에 액세스하려고 할 때도 같은 일이 일어납니다.
이 문제에 대해 가능한 (최소한) 세 가지 해결 방법이 있습니다.
Guido van Rossum은 from <module> import ...을 아예 사용하지 말고, 모든 코드를 함수 내에 배치할 것을 권장합니다. 전역 변수와 클래스 변수의 초기화는 상수나 내장 함수만 사용해야 합니다. 이것은 임포트 된 모듈의 모든 것이 <module>.<name>으로 참조됨을 의미합니다.
Jim Roskind는 각 모듈에서 다음 순서로 단계를 수행할 것을 제안합니다:
내보내기 (전역, 함수 및 베이스 클래스를 임포트 할 필요가 없는 클래스)
import문활성 코드 (임포트 된 값에서 초기화된 전역 포함).
Van Rossum은 임포트가 생소한 위치에 나타나기 때문에 이 방식을 선호하지 않지만, 작동은 합니다.
Matthias Urlichs는 처음부터 재귀 임포트가 필요하지 않도록 코드를 재구성할 것을 권합니다.
이 해결 방법들은 상호 배타적이지 않습니다.
__import__(‘x.y.z’)는 <module ‘x’>를 반환합니다; z를 어떻게 얻습니까?¶
importlib의 편의 함수 import_module()을 대신 사용하는 곳을 고려하십시오:
z = importlib.import_module('x.y.z')
임포트 된 모듈을 편집하고 다시 임포트 할 때, 변경 사항이 표시되지 않습니다. 왜 이런 일이 발생합니까?¶
효율성뿐만 아니라 일관성의 이유로, 파이썬은 모듈을 처음 임포트 할 때만 모듈 파일을 읽습니다. 그렇지 않으면, 각 모듈이 같은 기본 모듈을 임포트 하는 많은 모듈로 구성된 프로그램에서, 기본 모듈을 여러 번 구문 분석하고 다시 구문 분석하게 됩니다. 변경된 모듈을 강제로 다시 읽으려면, 다음과 같이 하십시오:
import importlib
import modname
importlib.reload(modname)
경고: 이 기법은 100% 확실하지 않습니다. 특히, 다음과 같은 문장을 포함하는 모듈의 경우 주의가 필요합니다:
from modname import some_objects
임포트 된 객체의 이전 버전으로 계속 작업합니다. 모듈에 클래스 정의가 포함되면, 새 클래스 정의를 사용하도록 기존 클래스 인스턴스가 갱신되지 않습니다. 이것은 다음과 같은 역설적인 동작으로 이어집니다:
>>> import importlib
>>> import cls
>>> c = cls.C() # C 인스턴스 생성
>>> importlib.reload(cls)
<module 'cls' from 'cls.py'>
>>> isinstance(c, cls.C) # isinstance가 False?!?
False
클래스 객체의 “아이덴티티”를 인쇄하면 문제의 본질이 분명해집니다:
>>> hex(id(c.__class__))
'0x7352a0'
>>> hex(id(cls.C))
'0x4198d0'