본문 바로가기

오탈자 정보

[러닝 파이썬(제5판)]_오탈자

현재까지 발견된 위 책의 오탈자 정보와 오류, 그리고 보다 매끄러운 문장을 위해 수정한 내용을 안내해드립니다. 번역과 편집 시에 미처 확인하지 못하고 불편을 끼쳐드려 죄송하다는 말씀을 드립니다. 아래의 오탈자 사항은 추후 재쇄 시에 반영하도록 하겠습니다. 


이외의 오탈자 정보를 발견하시면 옮긴이(ulzima@gmail.com)나 출판사(readers.jpub@gmail.com)로 연락주시면 고맙겠습니다.


최종수정일자: 2020년 9월 4일

2쇄본 오탈자


(업데이트순)


상편 86쪽 첫 번째 줄  (jj 님 제보)
3.X에서는 그렇지 않다). => 3.X에서는 그렇지 않다. 그리고 imp 모듈은 파이썬 3.4부터 deprecated되어서 importlib 모듈을 사용해야 한다).

상편 121쪽 위에서 열한 번째 줄  (jj 님 제보)
이러한 다른 종류의 객체들은 일반적으로 임포트에 의해 생성되고, 라이브러리 모듈(예를 들면, 패턴과 소켓을 위한 re와 socket 모듈이 있다)에 있는 함수들을 사용하며, 스스로 모든 동작을 제공한다.
=>
이러한 다른 종류의 객체들은 일반적으로 라이브러리 모듈(예를 들면, 패턴과 소켓을 위한 re와 socket 모듈이 있다)에 있는 함수들을 임포트해서 사용할 때 생성되며, 스스로 모든 동작을 제공한다.

상편 130쪽 세 번째 코드 박스 안  (jj 님 제보)
=> 패

상편 131쪽 밑에서 세 번째 줄  (jj 님 제보)
다음의 첫 번째 표현식에서 파이썬은 내부적으로 두 번째 인수를 첫 번째 인수에 자동으로 매핑하며,
=>
다음의 표현식들에서 파이썬은 내부적으로 첫 번째 방법을 두번째 방법으로 자동으로 매핑하지만,

상편 135쪽 위에서 여섯 번째 줄  (jj 님 제보)
객체의 데이터를 직접 변경하는 대부분의 연산을 리스트 객체가 지원한다
=>
객체의 데이터를 직접 변경하는 리스트 객체의 대부분의 연산을 지원한다.

상편 137쪽 위에서 다섯 번째 줄  (jj 님 제보)
이 예제는 'Hello, '로 시작하고 => 이 예제는 'Hello'로 시작하고

상편 143쪽 위에서 두 번째 줄  (jj 님 제보)
반환되도록 하기 위해서는 map 호출을 list로 강제로 감싸야 한다.
=>
반환되도록 강제하기 위해서는 map 호출을 list로 감싸야 한다.

상편 144쪽 위에서 네 번째 줄  (jj 님 제보)
순서를 제공하지 않는다. => 순서를 제공하지 않는(파이썬 3.6부터 딕셔너리는 삽입 순서대로 정렬된다).

상편 150쪽 위에서 두 번째 줄  (jj 님 제보)
순서를 유지하지 않는다. => 순서를 유지하지 않는다(파이썬 3.6부터 딕셔너리는 삽입 순서대로 정렬된다).

상편 152쪽 밑에서 열두 번째 줄  (jj 님 제보)
반복 객체는 iter 호출에 의해 생성되고, => 반복 객체는 iter 호출에 의해 떤 객체(이터레이터)를 생성하는데, 이 객체는

상편 152쪽 밑에서 아홉 번째 줄  (jj 님 제보)
컴프리헨션 제너레이터 표현식 => 제너레이터 컴프리헨션 표현식

상편 158쪽 첫 번째 코드 세 번째 줄의 주석  (jj 님 제보)
10바이트, 객체가 아닌 텍스트 => 10바이트, 객체나 텍스트가 아님

상편 160쪽 위에서 네 번째 줄  (jj 님 제보)
codes.open => codecs.open


상편 45쪽 위에서 여섯 번째 줄  (jj 님 제보)

딕셔너리 컴파일 => 사전 컴파일

열네 번째 줄

시맨틱 가비지 컬렉션의 비참조 카운트 기반의 설계는 => 참조 카운트를 기반으로 하지 않는 가비지 컬렉션 설계는

상편 49쪽 밑에서 열한 번째 줄  (jj 님 제보)

결과물과는 차이가 없으며 => 결과물과는 달라서


상편 54쪽 위에서 네 번째 줄  (jj 님 제보)
딕셔너리 준비 작업 -> => 사전 준비 작업

상편 61쪽 밑에서 열한 번째 줄  (jj 님 제보)
코드를 작성하기 위한 딕셔너리 준비 작업 => 코드를 작성하기 위한 사전 준비 작업
 
상편 62쪽 위에서 일곱 번째 줄  (jj 님 제보)
표현 방식들 => 표현식

상편 63쪽 마지막 줄  (jj 님 제보)
 => 모

상편 64쪽 첫 번째 줄  (jj 님 제보)
여러분의 행위가 위험해질 수 있다. => 위험에 빠지지 않을 수 있다.

상편 89쪽 밑에서 여섯 번째 줄  (jj 님 제보)
하든지, 아니면 처음 한번만 실행된다. => 하든, 처음 한 번만 실행된다.

상편 93쪽 밑에서 네 번째 줄  (jj 님 제보)
기본 import문은 프로세스가 실행되는 즉시 실행되며,
=> 
기본 import문은 프로세스마다 파일들을 각각 한번씩만 실행하며,

상편 93쪽 마지막 줄  (jj 님 제보)
코드를 변경한 다음에는 리로드 시에 모듈의 네임스페이스를 분할하기 위한 비용이 발생한다.
=> 
모듈의 네임스페이스를 분할됨으로써 발생하는 비용은 코드를 변경한 후에는 리로드를 해야 한다는 것이다.

상편 94쪽 위에서 열 번째 줄  (jj 님 제보)
대부부분의 플랫폼 -> 대부분의 플랫폼

상편 99쪽 밑에서 일곱 번째 줄, 열한 번째 줄  (jj 님 제보)
리로드해야 한다. => 리로드하면 된다.
 
상편 105쪽 위에서 다섯 번째 줄  (jj 님 제보)
* '할 수 있다'를 삭제하겠습니다.

상편 107쪽 마지막 줄  (jj 님 제보)
진입한 이때, -> 진입한다. 이때,


상편 388쪽 그림 9-3 하단 흰색 배경 글상자  (JeongHwi Ra 님 제보)

가터 => 기타


상편 739쪽 맨 아래쪽 코드문 마지막 줄

[35, 40} => [35, 40]


상편 777쪽 하단 코드문 다섯 번째 줄

for in => for i in


상편 790쪽 코드문 위에서 네 번째 줄

ret = fun(*pargs, **kargs) => ret = func(*pargs, **kargs)


상편 791쪽 밑에서 네 번째 줄

>>> timer.bestof(50, timer.total 1000 str.upper, 'spam') => >>> timer.bestof(50, timer.total, 1000, str.upper, 'spam')


상편 829쪽 밑에서 일곱 번째 줄 중간부

pystoen => pystone


상편 전체적으로

고전 클래스 => 레거시 클래스

드 => 메


상편 921쪽 열한 번째 줄

'고전적' 클래스 => '레거시' 클래스


상편 732쪽 첫 번째 코드 박스 첫째 줄  (유동우 님 제보)

>>> res = [x + y for x in [0, 1, 2] for y in in [100, 200, 300]] 

=>

>>> res = [x + y for x in [0, 1, 2] for y in [100, 200, 300]]



최종수정일자: 2018년 11월 29일

1쇄본 오탈자


(업데이트순)


상/하편 모두에서

고전 클래스 => 레거시 클래스 

드 => 메


하편 1101쪽 첫 번째 예제 코드 박스 일곱 번째 줄  (현재웅 님 제보)

I.method1() I.method2()

=>

I.method1()

I.method2()

(* 한 줄로 된 내용을 두 행으로 나누어야 합니다.)


상/하편 모두에서

다시 한 번 => 다시 한번


상편 349쪽 표 9-1 (Jae* Hyun 님 제보)




상편 571~590쪽 사이의 파이썬 버전 표기에 관하여 (Jae* Hyun 님 제보)

버전 3.6이라 표시된 부분을 모두 3.3으로 변경

(* 이 장은 지은이가 3.2 버전과 3.3 버전을 비교하는 내용이므로 최신 3.6이 아닌 3.3 버전으로 표기되었어야 함)


상편 920쪽 하단의 옮긴이 주 (Jae* Hyun 님 제보)

현재 파이썬의 최신 버전은 3.7이고, 이 책이 집필될 당시에는 3.3이 최신 버전이다.

=>

이 책이 집필될 당시의 최신 파이썬 버전은 3.3이었으나, 옮긴이는 번역 시점의 최신 버전인 3.6에서 모든 코드를 테스트했다. 부득이하게 버전 표기를 유지해야 할 곳은 3.3으로 되어 있지만, 내용을 이해하거나 테스트하는 데는 문제가 없을 것이다.


--------------------------------------10/12일자-------------------------------------- 


상편 8쪽 맨 마지막 줄 (Jae* Hyun 님 제보)

그러므로 일부 프로그램은 파이썬에서 C처럼 완전히 컴파일되는 언어보다 파이썬에서 더욱 느리게 실행될 것이다.

=>

그러므로 일부 프로그램은 C처럼 완전히 컴파일되는 언어보다 파이썬에서 더욱 느리게 실행될 것이다.


상편 123쪽 밑에서 두 번째 문단 (Jae* Hyun 님 제보)

파이썬의 오래된 버전에서는 부동 소수점 repr은 때로 여러분이 예상하는 것보다 더 많은 정밀도로 표시된다.

=>

파이썬의 오래된 버전에서는 부동 소수점 repr은 때로 여러분이 예상하는 것보다 더 높은 정밀도로 표시된다.


상편 181쪽 중간 예제 소스 (Jae* Hyun 님 제보)

#(4 / (2.0 +3))과 같음 [2.7 이전에서는 print를 사용] => #(4 / (2.0 + 3))과 같음

(* [ ]안 내용은 저자가 주석으로 설명을 단 것인데 조금 맥락에 안맞게 보일 수 있는 것 같아 삭제합니다.)


상편 233쪽 세 번째 줄 (Jae* Hyun 님 제보)

또한, 이러한 슬라이싱 기술은 딕셔너리가나 => 또한, 이러한 슬라이싱 기술은 딕셔너리나


상편 237쪽 학습 테스트 두 번째 소스 (Jae* Hyun 님 제보)

B= A => B = A


상편 240쪽 마지막 줄 (Jae* Hyun 님 제보)

이러한 구별 외에는 대부분 단순한 문자열 처리. => 이러한 구별 외에는 대부분 단순한 문자열 처리다. 


상편 257쪽 중간 (Jae* Hyun 님 제보)

아홉 번째 줄

s[1:3] 오프셋 1에서부터 오프셋 3까지의 아이템을 가져오며, 오프셋 3에 위치한 아이템은 제외된다.

=>

s[1:3] 오프셋 1에서부터 오프셋 2까지의 아이템을 가져오며, 오프셋 3에 위치한 아이템은 제외된다.


11번째 줄

s[:3] 오프셋 0에서부터 오프셋 3까지의 아이템을 가져오며, 오프셋 3에 위치한 아이템은 제외된다.

=>

s[:3] 오프셋 0에서부터 오프셋 2까지의 아이템을 가져오며, 오프셋 3에 위치한 아이템은 제외된다.


상편 277쪽 밑에서 두 번째 문단 (Jae* Hyun 님 제보)

다시 한 번 말하지만, 포매팅은 왼쪽에 있는 문자열을 변경하지 않고 항상 새로 문자열을 만든다는 것을 기억하자.

=>

다시 한번 말하지만, 포매팅은 왼쪽에 있는 문자열을 변경하지 않고 항상 새로 문자열을 만든다는 것을 기억하자.


상편 296쪽 위에서 세 번째 문단 (Jae* Hyun 님 제보)

튜플 자체를 값으로 전달하여 출력해야 하는 경우 중첩된 튜플을 전달해야 한다. 또한, 드물긴 하나 튜플 자체를 값으로 전달하여 출력해야 할 경우에는 중첩된 튜플을 전달해야만 한다.

=> 

결과적으로 단일 아이템은 그 자체로나 튜플로 감싼 후 제공될 수 있으며, 튜플 자체를 값으로 전달하여 출력해야 하는 경우 중첩된 튜플을 전달해야 한다. 

(* 빨간색으로 표시된 문장을 삭제)


상편 308쪽 첫 번째 예제 소스 (Jae* Hyun 님 제보)

>>>    res => >>> res


상편 309쪽 마지막줄 (Jae* Hyun 님 제보)

앞의 대화형 예제에서 리스트는 한 쌍의 괄호에 포함되어 있기 때문에

=> 

앞의 대화형 예제에서 리스트는 한 쌍의 대괄호에 포함되어 있기 때문에


상편 전체에서 (Jae* Hyun 님 제보)

드 => 메


상편 462쪽 첫 번째 예제 소스 두 번째 줄 (Jae* Hyun 님 제보)

>> print() => >>> print()


상편 462쪽 (Jae* Hyun 님 제보)

첫 번째 문단

이와 같은 결과 라인을 강제로 => 이와 같은 결과 라인을 강제로 


세 번째 문단 첫 번째 줄

여기서 단지 튜플에서 => 여기서 따옴표는 단순히 튜플에서


상편 483쪽 첫 번째 문단 (Jae* Hyun 님 제보)

그러나 예를 들어 다음 코드는 파이썬이 단축을 적용하지 않기 때문에 정확히 동일하지는 않다. => 그러나 예를 들어 다음 코드는 파이썬이 단축 연산(short-circuit)을 적용하지 않기 때문에 정확히 동일하지는 않다.


상편 504쪽 참고 내용 마지막 문단 (Jae* Hyun 님 제보)

또한 여기서 for 루프는 각 문자를 처리하지만, for 루프는 파일을 (한 번에 읽기에 충분한 경우) 한 번에 모두 메모리로 읽는다.

=> 

또한 여기서 for 루프는 각 문자를 처리하지만, file.read()는 파일을 (한 번에 읽기에 충분한 경우) 한 번에 모두 메모리로 읽는다.

 

상편 506쪽 세 번째 불릿 기호 내용 (Jae* Hyun 님 제보)

(파이썬2.3 이후로 사용할 수 있는) 내장 enumerate 함수는 가변 객체의 아이템들에 대한 값과 인덱스를 생성하므로 수동으로 카운팅할 필요가 다.

(파이썬2.3 이후로 사용할 수 있는) 내장 enumerate 함수는 가변 객체의 아이템들에 대한 값과 인덱스를 생성하므로 수동으로 카운팅할 필요가 다.

 

상편 509 마지막 예제 소스 세 번째 줄 (Jae* Hyun 님 제보)

#제일 앞 아이템으로 끝으로 이동

#제일 앞 아이템 끝으로 이동


상편 548쪽 세 번째 문단 (Jae* Hyun 님 제보)

좀 더 자세한 내용은 20장에서 살펴보겠지만, map이나 zip 같이 한 번의 탐색만을 지원하며, 새롭게 반복 객체가 된 도구들에 대해 여러 번의 반복을 지원하기 위해서 리스트로 변환할 경우에는 주의가 필요하다.

=> 

좀 더 자세한 내용은 20장에서 살펴보겠지만, map zip 같이 한 번의 탐색만을 지원하는 새로운 반복 객체에 대한 다중 반복은 좀 더 세밀한 지원이 필요하다.


상편 571쪽 (Jae* Hyun 님 제보)

첫 번째 문단의 마지막 줄

그리고 이를 실행하는 방법은 파이썬 3.6 이후부터 변경되었다.

=>

그리고 이를 실행하는 방법은 파이썬 3.3 버전부터 변경되었다.


두 번째 불릿 기호 내용

3.6 이후부터 이전 GUI 클라이언트는 => 파이썬 3.3 부터 이전 GUI 클라이언트는

 

상편 602쪽 주석 내용 (Jae* Hyun 님 제보)

기본 개념은 '당신의 코드는 객체가 꽥꽥 울지 않는 한, 그 객체가 오리인지 아닌지에 대해서는 상관하지 않는다'는 것이다.

=>

기본 개념은 '당신의 코드는 객체가 꽥꽥하고 우는 한, 그 객체가 오리인지 아닌지에 대해서는 상관하지 않는다'는 것이다.

 

상편 664쪽 표 18-1 맨 마지막 칸 (Jae* Hyun 님 제보)

def func(*, 이름 = 값) => def func(*기타, 이름 = 값)


상편 701쪽 두 번째 예제 소스 밑에서 두 번째 줄 (Jae* Hyun 님 제보)

items.extend(front) => items[:0] = front

 

상편 735쪽 두 번째 예제 소스에 첫 번째 주석문 (Jae* Hyun 님 제보)

# 을 이용한 같은 기능 => # for문을 이용한 같은 기능

 

상편 736쪽 첫 번째 문단 (Jae* Hyun 님 제보)

이 코드는 다음의 기반 코드와 같다. => 이 코드는 다음의 for문 기반 코드와 같다.

 

상편 751 첫 번째 예제 소스 첫 줄 (Jae* Hyun 님 제보)

>>> list = 'aaa,bbb,ccc' => >>> line = 'aaa,bbb,ccc'


상편 752쪽 세 번째 문단 (Jae* Hyun 님 제보)

예를 들어, 예를 들어, 다음은 중첩보다는 비중첩이 일반적으로 더 낫다는

=> 

예를 들어, 다음은 중첩보다는 비중첩이 일반적으로 더 낫다는


상편 765쪽 예제 소스 첫 번째 함수 (Jae* Hyun 님 제보)

>>> def scramble(seq):

            for i in range(len(seq)):

            seq = seq[1:] + seq[:1]

            yield seq

=> 

>>> def scramble(seq):

            for i in range(len(seq)):

                seq = seq[1:] + seq[:1]

                yield seq

(* 들여쓰기가 틀림. 세, 네 번째 줄을 한 번 더 들여써야 합니다.)


상편 794쪽 예제 소스 밑에서 열 번째 줄 (Jae* Hyun 님 제보)

def getFunc(): => def genFunc():


상편 818쪽 첫 번째 문단 (Jae* Hyun 님 제보)

비록 사용자 정의 함수가 내장 함수보다 더 느릴 수는 있지만, 일반적으로 함수가 내장인지 아닌지가 성능에 영향을 많이 주는 것 같아 보인다.

=> 

비록 사용자 정의 함수가 내장 함수보다 더 느릴 수는 있지만, 일반적으로 함수가 내장이든 아니든 함수 자체가 속도 면에서 큰 부분을 차지한다는 것을 알 수 있다.


상편 822쪽 두 번째 문단 (Jae* Hyun 님 제보)

여러분도 알다시피, 파이썬은 함수 안에서 할당된 이름을 기본적으로 지역(지역)로 분류한다.

=>

여러분도 알다시피, 파이썬은 함수 안에서 할당된 이름을 기본적으로 지역(locals)으로 분류한다.


상편 826쪽 첫 번째 예제 소스 세 번째 줄 (Jae* Hyun 님 제보)

print((saver.x) => print(saver.x)


하편 1554쪽 예제 소스 여섯 번째 줄 (Jae* Hyun 님 제보)

# 혹은 다른 호줄 가능 객체 => # 혹은 다른 호출 가능 객체


--------------------------------------8/13일자-------------------------------------- 


상편 xxxiv쪽, 하편 xxxiii쪽 마지막 URL (Jae* Hyun 님 제보)

Learnin-python.com/index-book-links.html

=>

Learning-python.com/index-book-links.html


상편 554쪽 첫 번째 코드 밑에서 세 번째 줄 (Jae* Hyun 님 제보)

for k in D.kesy(): print(k, end=‘ ’)

=>

for k in D.keys(): print(k, end=‘ ’)


상편 685쪽 첫째 줄 (Jae* Hyun 님 제보)

(그러려면 전체 순열이 필요하며, 네 개의 인수의 경우 총 2네 개의 순서가 생긴다)

=>

(그러려면 전체 순열이 필요하며, 네 개의 인수의 경우 총 24개의 순서가 생긴다)


상편 718쪽 두 번째 코드 첫 번째 줄 (Jae* Hyun 님 제보)

action = (labda x  : (lambda y: x+y))

=>

action = (lambda x  : (lambda y: x+y))


상편 733쪽 첫 번째 코드 첫 번째 줄 (Jae* Hyun 님 제보)

>>> [(x, y] for x in range(5) if x % 2 == 0 for y in range(5) if y % 2 == 1]

=>

>>> [(x, y) for x in range(5) if x % 2 == 0 for y in range(5) if y % 2 == 1]


상편 752쪽 첫 번째 코드 네 번째 줄 (Jae* Hyun 님 제보)

[1, 0 1]

=>

[1, 0, 1]


상편 755쪽 첫 번째 코드 첫 번째 줄 (Jae* Hyun 님 제보)

>>> def timefour(S):

=>

>>> def timesfour(S):


상편 758쪽 두 번쨰 코드 마지막 줄 (Jae* Hyun 님 제보)

'0 : 1 : 2 : 3 : 4 : 0 : 1 : 4 : 9 : 16"

=>

'0 : 1 : 2 : 3 : 4 : 0 : 1 : 4 : 9 : 16'


상편 770쪽 코드 밑에서 두 번째 줄 (Jae* Hyun 님 제보)

>>> len(p1) p1[0], p1[1]

=> 

>>> len(p1), p1[0], p1[1]

(* 쉼표 누락 추가)


하편 1116쪽 표 제목

표 30-3 => 표 30-1



  • 으악 2019.07.26 12:17

    으아.. 제가 갖고있는 책은 1쇄본인데.. 아주 오탈자 잔치가 열렸네요, 잔치가...

    • 죄송합니다. 오랜 시간 동안 공들여 펴냈는데도 오탈자가 예상 외로 많았습니다. ㅠㅠ 번거로우시겠지만 책에 오탈자 내용을 반영하신 후 보시기를 바랍니다. 유구무언이라 죄송하다는 말씀 외에는 드릴 말이 없네요...

  • jj 2020.08.29 03:53

    2쇄

    상편 45p 위에서 6번째 줄
    "딕셔너리" 컴파일 -> "사전(prerun)" 컴파일

    상편 45p 밑에서 14번째 줄
    시맨틱 가비지 컬렉션의 "비참조" 카운트 기반의 설계는 -> "참조 카운트를 기반으로 하지 않는" 가비지 컬렉션 설계는

    상편 49p 밑에서 11번째 줄
    결과물과는 "차이가 없으며" -> 결과물과는 "달라서"

    상편 54p 위에서 4번째 줄
    "딕셔너리" 준비 작업 -> "사전"(事前) 준비 작업(preliminaries)

    상편 61p 밑에서 11번째 줄
    코드를 작성하기 위한 "딕셔너리" 준비 작업 -> 코드를 작성하기 위한 "사전"(事前) 준비 작업

    상편 62p 위에서 7번째 줄
    "표현 방식"들 -> "표현식(expression)"들

    상편 63p 마지막 줄
    "모둘" -> "모듈"

    상편 64p 1번째 줄
    "여러분의 행위가 위험해질 수 있다" -> "위험에 빠지지 않을 수 있다"

    상편 85p 마지막 줄, 86p 상단의 코드
    imp 모듈은 파이썬 3.4부터 deprecated되어서 importlib 모듈을 사용해야 함.

    상편 89p 밑에서 6번째 줄
    "아니면" 처음 한번만 실행된다 -> 처음 한번만 실행된다

    상편 93p 밑에서 4번째 줄
    기본 import문은 프로세스가 실행되는 즉시 실행되며,
    ->
    기본 import문은 프로세스마다 파일들을 각각 한번씩만 실행하며,

    상편 93p 마지막 줄
    코드를 변경한 다음에는 리로드 시에 모듈의 네임스페이스를 분할하기 위한 비용이 발생한다.
    ->
    모듈의 네임스페이스를 분할할 수 있어서 발생하는 비용은 코드를 변경한 후에는 리로드를 해야 한다는 것이다.

    상편 94p 위에서 10번째 줄
    "대부부분"의 플랫폼 -> "대부분"의 플랫폼

    상편 99p 밑에서 7번째 줄, 11번째 줄
    리로드"해야 한다." -> 리로드"하면 된다."

    상편 100p 밑에서 5번째 줄
    파이썬 3.4부터 -n 플래그 deprecated

    상편 105p 위에서 5번째 줄
    "할 수 있다" -> 삭제

    상편 107p 마지막 줄
    진입한다 이때, -> 진입한다. 이때,

    상편 121p 위에서 11번째 줄
    이러한 다른 종류의 객체들은 일반적으로 임포트에 의해 생성되고, 라이브러리 모듈(...)에 있는 함수들을 사용하며, 스스로 모든 동작을 제공한다.
    ->
    이러한 다른 종류의 객체들은 일반적으로 라이브러리 모듈(...)에 있는 함수들을 임포트해서 사용할 때 생성되며, 스스로 모든 동작을 제공한다.

    상편 130p 세번째 코드 박스 안
    패팅 -> 패딩

    상편 131p 밑에서 3번째 줄
    다음의 첫 번째 표현식에서 ... 매핑하며, ...
    ->
    다음의 표현식들에서 파이썬은 내부적으로 첫번째 방법을 두번째 방법으로 자동으로 매핑하지만, ...

    상편 135p 위에서 6번째 줄
    객체의 데이터를 직접 변경하는 대부분의 연산을 리스트 객체가 지원한다
    ->
    객체의 데이터를 직접 변경하는 리스트 객체의 대부분의 연산을 지원한다.

    상편 137p 위에서 5번째 줄
    이 예제는 'Hello, '로 시작하고 -> 이 예제는 'Hello'로 시작하고

    상편 143p 위에서 2번째 줄
    반환되도록 하기 위해서는 map 호출을 list로 강제로 감싸야 한다.
    ->
    반환되도록 강제하기 위해서는 map 호출을 list로 감싸야 한다.

    상편 144p 위에서 3번째 줄, 150p 위에서 1번째 줄
    파이썬 3.6(역서 기준)부터 딕셔너리는 삽입 순서대로 정렬이 보장되어 있음.

    상편 152p 밑에서 12번째 줄
    반복 객체는 iter 호출에 의해 생성되고,
    ->
    반복 객체는 iter 호출에 의해 어떤 객체(이터레이터)를 생성하는데, 이 객체는

    상편 152p 밑에서 9번째 줄
    컴프리헨션 제너레이터 표현식 -> 제너레이터 컴프리헨션 표현식

    상편 158p 1번째 코드의 3번째 줄의 주석
    10바이트, 객체가 아닌 텍스트 -> 10바이트, 객체나 텍스트가 아님

    상편 160p 위에서 4번째 줄
    codes.open -> codecs.open

    상편 171p 위에서 3번째 줄
    "부호부와 지수부," -> 삭제

    상편 172p 밑에서 8번째 줄
    복소수는 complex(real, imag)가 내장된 호출을 사용하여 만들 수 있다.
    ->
    복소수는 내장된 호출 complex(real, imag)을 사용하여 만들 수도 있다.

    상편 174p의 표 5-2
    일부 연산자들이 우선순위가 같음에도, 별도의 셀에 위치하고 있어서 우선 순위가 다른 것처럼 보입니다.
    https://learning-python.com/LP5E-Table-5-2-After.pdf 로 수정되어야 합니다.

    상편 175p 위에서 6번째 줄
    역인용 부호 표현식 'x'는 -> 역인용 부호 표현식 `x`는

    상편 183p str과 repr 출력 형식의 밑에서 3번째 줄
    디코드하기 위한 인코딩 이름으로 사용된다.
    ->
    디코드하기 위해 인코딩 이름을 넘기면서 호출되기도 한다.

    상편 184p 위에서 7번째 줄
    다음 부울 테스트 -> 부울 테스트

    상편 187p 위에서 3번째 줄
    이러한 점은...
    ->
    이러한 점은 3.X에서 그 동작이 바뀐 계기가 된 2.X에서의 / 연산자의 타입 의존적인 동작과 유사해보일 수도 있지만, 리턴 값의 타입만 의존할 뿐 리턴 값 자체가 의존하진 않으므로 덜 치명적이다.
    (예를 들어 2.X에서 3/2=1, 3/2.0=1.5이라서 값 자체가 달라지지만, 3.X에서는 3//2=1, 3//2.0=1.0)

    상편 192p 밑에서 11번째 줄
    복소수는 자신의 각 부분을 속성처럼 -> 복소수는 속성을 통해 자신의 각 부분을

    상편 196p 두번째 코드의 마지막 주석
    1진수 -> 16진수

    상편 202p 마지막 코드의 마지막 줄
    >>> pay Decimal('2000.33')
    ->
    >>> pay
    Decimal('2000.33')

    상편 204p 밑에서 2번째 줄
    분수와 소수의 수치 정밀도는... 주의하자.
    ->
    분수와 소수의 수치 정밀도는, 내부의 부동 소수점 수 하드웨어의 한계에 제약을 받는 부동 소수점 수 타입 계산과는 다르다는 점에 주의하자.

    상편 212p 첫번째 코드의 두번째 주석
    가변 객체 안의 모든 아이템 추가 -> 반복 가능 객체 안의 모든 아이템 추가

    상편 214p 밑에서 9번째 줄
    리스트 컴프리헨션은 루프를 반복할 때마다 -> 집합 컴프리헨션은 루프를 반복할 때마다

    상편 239p 위에서 3번째 줄
    정렬되지 않은 -> 정렬된

    상편 245p 밑에서 2번째 줄
    시퀀스처럼 보여 주지만, -> 이스케이프 시퀀스로 보여 주지만,

    상편 249p 위에서 1번째 줄
    그러나 이 방법이... 의존할 수 없을 것이다.
    ->
    그러나 표 7-2에 나열된 모든 유효한 이스케이프 시퀀스를 외우고 있는 게 아닌 한, 여러분은 아마도 이 동작에 의존하고 싶진 않을 것이다.

    상편 250p 부연 설명 부분 밑에서 5번째 줄
    두 번째 역슬래시를 잘라내거나(r'1/nb/tc/ /'[:-1]), -> 두 번째 역슬래시를 잘라내거나(r'1/nb/tc//'[:-1]),
    (댓글 란에서 역슬래시가 제대로 보이지 않아서 대신 /로 표시합니다)

    상편 250p 부연 설명 부분 밑에서 3번째 줄
    슬래시만 이중으로 -> 역슬래시만 이중으로

    상편 262p 위에서 3번째 줄
    실제 바이너리 값을 반환한다 -> 실제 숫자 값을 반환한다

    상편 262p 위에서 5번째 줄, 6번째 줄
    대응하는 유니코드 또는 '코드 포인트' 사이를 서로 변환하며, -> 대응하는 유니코드 서수 값 또는 '코드 포인트' 사이를 서로 변환하며,
    유니코드와 코드 포인트는 -> 유니코드 서수 값 또는 코드 포인트는

    상편 271p 위에서 3번째 줄
    또한 어떤 구분자의 종류로 데이터를 분리하는 대신, -> 어떤 구분자의 종류가 데이터를 분리한다면,

    상편 275p 밑에서 14번째 줄
    문자열 포매팅 메서드 호출: '...{}...'.format (값들) -> 문자열 포매팅 메서드 호출: '...{}...'.format(값들)

    상편 276p 밑에서 4번째 줄
    (또는 튜플에 내장 객체들) -> (또는 튜플에 내장된 객체들)

    상편 279p 위에서 1번째 줄
    숫자 기호(+) -> 숫자 부호(+)

    상편 293p 밑에서 10번째 줄
    여기서 comma 함수는 -> 여기서 commas 함수는

    상편 306p 표 8-1 밑에서 2번째 행
    리스트 컴프리헨션과 맵(4장, 14장, 20장) -> 리스트 컴프리헨션(4장, 14장, 20장)

    상편 306p 첫번째 문단
    두 번째 열 -> 두 번째 행
    (3열) -> (3행)
    (1열) -> (1행)

    상편 311p 페이지 하단의 부연 설명 부분 2번째 줄
    왼쪽에서 삭제가 발생하기 먼저 가져오기 때문에 -> 왼쪽에서 삭제가 발생하기 "전에" 먼저 가져오기 때문에

    상편 313p 페이지 하단의 부연 설명 부분 4번째 줄
    예를 들어, L.insert(0, X) 구문 마찬가지로 -> 예를 들어, L.insert(0, X) 구문"도" 마찬가지로

    상편 314p 1번째 줄
    앞에 "key 인수는" 추가

    상편 318p 밑에서 2번째 줄
    해당 값은 다수의 키를 저장할 수 있다. -> 주어진 값 자체는 다수의 키에 연관되어 저장될 수 있다.

    상편 321p 밑에서 8번째 줄
    뒤에 "(파이썬 3.6부터 딕셔너리는 삽입 순서대로 정렬된다)." 추가

    상편 329p 세번째 코드의 주석
    # ;문들을 구분: 10장 참고 -> # ;는 문들을 구분: 10장 참고

    상편 330p 밑에서 6번째 줄
    예를 들면 키가 존재하지 않는 경우에는 ... 확인할 수 있다.
    ->
    예를 들면 사전에 미리 키가 존재하는지 확인하기 위해 if문을 사용하거나, 예외를 명시적으로 붙잡아 처리하는 try문을 사용하거나, 또는 단순히 딕셔너리의 get 메서드를 사용하여 키가 존재하지 않는 경우에는 기본값을 제공할 수 있다.

    상편 330p 코드의 3번째 주석
    # 인덱스 try -> # 인덱스를 시도한다.

    상편 331p 두번째 코드
    'web': 'www.bobs.org/~Bob' (물결 표시가 문자 B와 이상하게 겹쳐 있음)

    상편 336p 밑에서 7번째 줄
    항상 이 둘을 함께 묶어서... 만들 수 있다. -> 항상 이 둘 각각을 리스트로 만든 뒤 묶어서 딕셔너리로 만들 수 있다.

    상편 337p 첫번째 코드의 주석, 두번째 코드의 주석
    가변 객체 -> 반복 가능 객체

    상편 338p 밑에서 4번째 줄
    14장에서 가변 객체의 -> 14장에서 반복 가능한 객체의

    상편 339p 위에서 1번째 줄
    파이썬에서 루프 구조는 ... 대화형 프롬프트에서...
    ->
    파이썬에서 루프 구조는 반복 가능한 객체로 하여금 각 반복 때마다 자동으로 하나씩 결과를 생성하도록 하므로 대화형 프롬프트에서...

    상편 339p 위에서 4번째 줄
    또한, 3.X에서 딕셔너리는 ... 반복자(iterator)다.
    ->
    또한, 3.X에서도 여전히 딕셔너리는 스스로, 연속적인 키를 반환하는 반복자(iterator)를 갖는다.

    상편 340p 밑에서 4번째 줄
    "딕셔너리의" 항목들은 반드시 -> "딕셔너리의 값의 뷰의" 항목들은 반드시

    상편 342p 첫번째 코드의 네번째 주석
    sorted()는 모든 가변 객체를 허용함 -> sorted()는 모든 반복 가능한 객체를 허용함

    상편 354p 위에서 7번째 줄, 세번째 코드의 두번째 주석
    함게 유사한 역할 -> 함께 유사한 역할
    튜플 항목들로 변환된 리스트 -> 튜플의 리스트로 변환된 항목들

    상편 359p 마지막 줄
    스크립트를 -> 삭제

    상편 360p 위에서 10번째 줄
    엄밀히 말하면, 컬렉션 시에 -> 엄밀히 말하면, 가비지 컬렉션 시에

    상편 362p 밑에서 7번째 줄
    파일 끝 문자 변환을 기본으로 수행한다. -> 라인 끝 문자 변환을 기본으로 수행한다.

    상편 368p 밑에서 7번째 줄
    게다가 JSON은 구문적으로 파이썬 사진과 -> 게다가 JSON은 구문적으로 파이썬 딕셔너리와

    상편 371p 첫번째 코드의 3행
    >>> data b'에서 b'를 다음 행의 가장 앞으로 이동

    상편 372p 밑에서 7번째 줄(마침표 없음)
    파일 스캐너 루프 코드 패턴에 대해 이야기한다.

    상편 373p 위에서 3번째 줄
    pickle을 이용할 수 있는 파이썬 객체를 -> pickle로 직렬화한 파이썬 객체를

    상편 374p 위에서 10번째 줄
    표 9-3의 '문자'는 -> 표 9-3의 '문자열'은

    상편 381p 밑에서 13번째 줄
    딕셔너리적으로 -> 사전 편찬 순서대로(lexicographically)

    상편 392p 밑에서 5번째 줄, 밑에서 2번째 줄
    가변 객체는 직접 변경할 수 없다. -> 불변 객체는 직접 변경할 수 없다.
    튜플과 문자열 같은 가변 객체를 -> 튜플과 문자열 같은 불변 객체를

    상편 394p 위에서 8번째 줄
    튜플은 가변이기 때문에 -> 튜플은 불변이기 때문에

    상편 402p 위에서 3번째 줄
    또한 문은 어디선가 불쑥 나타날 수 있으며 -> 또한 문은 객체가 등장하는 곳이며

    상편 412p 밑에서 8번째 줄
    (그 외에도 전체 프로그램을 한 라인에 밀어 넣을 수도 있지만,
    ->
    (그렇지 않으면, 전체 프로그램을 한 라인에 밀어 넣을 수도 있게 될테지만,

    상편 415p 코드
    input('Enter text') -> input('Enter text:')
    if reply = -> if reply ==

    상편 416p 부연 설명 부분의 밑에서 2번째 줄
    마친 파이썬 코드인 것처럼 -> 마치 파이썬 코드인 것처럼

    상편 428p 위에서 5번째 줄
    모든 이진 표현식 연산자 -> 모든 이항 표현식 연산자

    상편 432p 위에서 2번째 줄
    문자열로 처리하는 것이 -> 연결하여 처리하는 것이

    상편 443p 위에서 7번째 줄, 8번째 줄, 부연 설명 부분
    파이썬 2.6까지는 -> 파이썬 2.6 이전까지는
    파이썬 2.3까지는 -> 파이썬 2.3 이전까지는
    파이썬의 또 다른 구현인 표준 CPython에서는 적어도 -> 적어도 표준 CPython에서는 그렇다. 파이썬의 또 다른 구현들에서는

    상편 444p 부연 설명 부분 밑에서 8번째 줄
    오랜 시간 동안 단계적으로 도입 중이다. -> 오랜 시간 동안 단계적으로 도입 중이었다.

    상편 454p 표 11-5의 테이블 헤더
    파이썬 3.X문 -> 파이썬 3.X 함수

    상편 475p 밑에서 6번째 줄
    이러한 이유로 인해 블록 안에서 -> 이러한 이유로 인해 하나의 블록 안에서

    상편 476p 밑에서 4번째 줄
    밀어 넣이기 위해 -> 밀어 넣기 위해

    상편 478p 위에서 8번째 줄
    /naaa/nbbb/nccc이 할당되며 -> /naaaa/nbbbb/ncccc이 할당되며
    (댓글 란에서 역슬래시가 제대로 보이지 않아서 대신 /로 표시합니다)

    상편 496p 밑에서 2번째 줄
    또는 가변 객체 안의 -> 또는 반복 가능 객체 안의

    상편 497p 위에서 1번째 줄, 위에서 6번째 줄
    가변 객체 -> 반복 가능 객체

    상편 502p 위에서 1번째 줄
    데이터의 열로부터 -> 데이터의 행으로부터

    상편 505p 부연 설명 부분의 밑에서 14번째 줄, 밑에서 1번째 줄
    임의의 가변 객체는 허용되지 않는다. -> 임의의 반복 가능 객체는 허용되지 않는다.
    가변 객체 -> 반복 객체

    상편 506p 밑에서 12번째 줄
    내장 enumerate 함수는 가변 객체의 -> 내장 enumerate 함수는 반복 가능 객체의

    상편 507p 밑에서 9번째 줄
    이와 같은 가변 객체에 -> 이와 같은 반복 객체에

    상편 513p 위에서 9번째 줄, 위에서 10번째 줄
    출력하기 위해 zip으로 감싸야만 하는 -> 출력하기 위해 list로 감싸야만 하는
    다시 이야기하지만, 가변 객체에 -> 다시 이야기하지만, 반복 가능한 객체에

    상편 514p 위에서 5번째 줄
    (실제로, 파일을 포함한 모든 가변 객체), -> (실제로, 파일을 포함한 모든 반복 가능한 객체),

    상편 520p 세번째 코드의 위에서 2번째 줄
    learing-python -> learning-python

    상편 521p 위에서 4번째 줄, 위에서 8번째 줄, 밑에서 6번째 줄
    가변 객체 -> 반복 가능 객체

    상편 524p 코드 위에서 1번째 줄
    end' ' -> end=' '

    상편 525p 부연 설명 부분의 위에서 5번째 줄
    이 두 호출은 앞서 이미 정의한 바 있다. -> 이 두 호출은 앞으로 정의할 것이다.

    상편 525p 밑에서 2번째 줄
    다음 라인으로 진행한다. -> 이 메서드는 호출할 때마다 다음 라인으로 진행한다.

    상편 537p 위에서 5번째 줄
    시퀀스에 포함된 각 아이템에 "대한 연산의" 연산을 수행하는 -> 시퀀스에 포함된 각 아이템에 "대해" 연산을 수행하는

    상편 540p 세번째 코드의 실행 결과
    ['al', ... 'cl', 'cm', 'cl'] -> ['al', ... 'cl', 'cm', 'cn']

    상편 545p 위에서 5번째 줄, 위에서 7번째 줄
    집합 컴프리헨션과 딕셔너리는 -> 집합 컴프리헨션과 딕셔너리 컴프리헨션은

    상편 550p 밑에서 8번째 줄
    파이썬 3.X에서 zip, 그리고 filter 내장 함수는 -> 파이썬 3.X에서 map, zip, 그리고 filter 내장 함수는

    상편 551p 부연 설명의 위에서 4번째 줄, 부연 설명의 위에서 5번째 줄
    CPython 2.7과 3.6에서 일부 테스트에서 해당하는 -> CPython 2.7과 3.6의 일부 테스트에서 대응하는
    또 다른 테스트에서는 아주 미묘하고 빠르게 실행되기도 하며, -> 또 다른 테스트에서는 아주 미묘하게 빠른 정도이기도 하며,

    상편 552p 위에서 4번째 줄, 위에서 6번째 줄
    range 객체가 내장된 range 함수와 어떻게 다른지 -> range 객체가 내장된 zip, map, filter와 어떻게 다른지
    자신의 위치를 독립적으로 기억하는... -> range 객체의 결과에 대해 자신의 위치를 독립적으로 기억하는 다수의 반복자를 지원한다.

    상편 553p 코드에서 밑에서 5번째 줄(콤마 없음)
    I1, I2 = iter(R) iter(R) -> I1, I2 = iter(R), iter(R)

    상편 556p 위에서 9번째 줄
    가변 객체에 포함된 -> 반복 객체에 포함된

    상편 559p 위에서 5번째 줄
    셸에서 일반적인 테스트 -> 셸에서 일반적인 텍스트

    상편 567p 위에서 4번째 줄
    마침내 파이썬이 문서화 문자열을...
    ->
    문서화 문자열이 매우 유용하다는 것이 증명되었기 때문에 파이썬은 마침내 문서화 문자열을 좀 더 쉽게 표시하기 위한 도구를 추가했다.

    상편 595p 위에서 6번째 줄
    아무 딕셔너리 준비없이 -> 아무 사전 준비없이

    상편 597p 목록의 두번째 항목(굵은 글자 효과 제거)
    "파이썬에서 인수는 할당에 의해 함수에 전달된다."

    상편 605p 부연 설명 부분
    _contains_ -> __contains__
    _iter_ -> __iter__
    _getitem_ -> __getitem__

    상편 609p 밑에서 6번째 줄
    긍정적인 면을 보자면, 전역 범위가 -> 긍정적인 면을 보자면, 범위가

    상편 619p 2번째 코드에서 2번째 주석
    원하는 것은 전역임 -> 원하는 것은 지역임

    상편 621p 위에서 1번째 줄
    파이썬의 선언문 중, 유일하게 약간 닮은꼴이라고 -> 파이썬에서 유일하게 선언문과 닮았다고

    상편 626p 첫번째 코드
    glob2() 뒤에 콜론 : 추가, test() 뒤에 콜론 : 추가

    상편 630p 위에서 3번째 줄
    다음과 같이 -> 위와 같이

    상편 633p 두번째 코드
    f1() 뒤에 콜론 : 추가

    상편 634p 두번째 코드
    func() 뒤에 콜론 : 추가

    상편 638p 밑에서 10번째 줄, 밑에서 1번째 줄
    함수 선언한 지역 범위 -> 함수에서 선언한 지역 범위
    nonlocal 문은 바깥쪽 범위의 이름을 단순히... -> nonlocal 문은 바깥쪽 범위의 이름을 단순히 참조하는 것 뿐만 아니라 변경이 필요할 때에도 사용된다.

    상편 642p 코드의 두번째 줄, 3번째 줄
    nonlocal sapm -> nonlocal spam
    아니면 외부 모듈에 할당되어야 할까? -> 아니면 외부에 위치한 모듈에 할당되어야 할까?

    상편 650p 세번째 코드의 밑에서 4번째 줄, 세번째 코드의 밑에서 2번째 줄
    builtin.open = self -> builtins.open = self
    %self.id -> % self.id

    상편 664p 표 18-1의 마지막 행
    def func(*기타, 이름=값) -> def func(*, 이름=값)

    상편 666p 부연 설명 부분 밑에서 2번째 줄(화살표 모양)
    def f() -> value 형식

    상편 667p 밑에서 4번째 줄
    함수 인수를 선택할 수 있도록 한다. -> 함수 인수를 생략할 수 있도록 한다.

    상편 670p 위에서 6번째 줄
    키워드를 딕셔너리로 전환함으로써 key 호출 -> 키워드 인수들을 딕셔너리로 전환함으로써 keys 호출

    상편 675p 밑에서 4번째 줄
    지정된 인수로 작성된다. -> 이름있는 인수로 작성된다.

    상편 695p 밑에서 2번째 줄
    가장 직관적인 방법이다. -> 삭제

    상편 702p 밑에서 4번째 줄
    이미 처리된 상태를 추가하여 -> 이미 처리된 상태를 추가하는 것을

    상편 706p 위에서 2번째 줄
    1장에서 소개된 -> 13장에서 소개된

    상편 733p 밑에서 7번째 줄
    이러한 코드는 전 리스트 프로그래머를 -> 이러한 코드는 전에 Lisp을 경험해본 프로그래머를

    상편 734p 세번째 코드(앞에 여는 대괄호 추가)
    M[i][len(M)-1-i] -> [M[i][len(M)-1-i]

    상편 735p 밑에서 5번째 줄
    각 열에 대해 결과 행렬의 한 열을 -> 각 행에 대해 결과 행렬의 한 행을

    상편 743p 위에서 7번째 줄
    제너레이터는 자동으로 -> 제너레이터 함수는 자동으로

    상편 745p 위에서 5번째 줄, 위에서 11번째 줄
    수동으로 저장하기 위한 -> 수동으로 저장하는 것에 대한
    튜플 호출 -> tuple 호출

    상편 746p 위에서 1번째 줄
    모든 결과를 한 번에 생성하므로... -> 결과 세트가 너무 커서 한 번에 생성할 수 없는 경우에는 그 중 일부 요소만을

    상편 748p 위에서 4번째 줄
    또한, 반복 객체는 실행 중인 동안... -> 또한, 반복 객체는 실행 중인 동안 제너레이터의 상태(제너레이터의 코드 위치와 위 표현식에서 변수 x)를 유지한다.

    상편 750p 밑에서 4번째 줄
    테스트 -> 텍스트

    상편 751p 첫번째 코드의 5번째 줄
    ''.join(x,upper() -> ''.join(x.upper()

    상편 752p 두번째 코드의 5번째 줄
    (-1, 0 1) -> (-1, 0, 1)

    상편 756p의 중간에 있는 코드
    for c i 'SPAM' -> for c in 'SPAM'

    상편 758p 부연 설명의 제목
    확장으로부터의 파이썬 3.3 yield -> 파이썬 3.3의 yield from 확장

    상편 760p 위에서 1번째 줄
    특정 유형의 -> 특정 타입의

    상편 775p 첫번째 코드
    def mymap(func, *seqs); -> def mymap(func, *seqs):
    res = [] -> 삭제
    for args in zip(seqs)) -> for args in zip(*seqs)
    def mymap(func, "seqs); -> def mymap(func, *seqs)

    상편 776p 위에서 2번째 줄, 위에서 3번째 줄
    가변 객체 -> 반복 객체

    상편 778p 코드의 5번째 줄
    for in range(minlen) -> for i in range(minlen)

    상편 779p 세번째 코드
    def myzip("args): -> def myzip(*args):

    상편 781p 위에서 2번째 줄
    이러한 확장들 내에서 -> 이러한 표현식들 내에서

    상편 783p 마지막 코드에 마지막 실행 결과 누락됨. 6번째 줄로 추가
    {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

    상편 784p 첫번째 코드의 3번째 줄
    ">>> {x * y" -> ">>> {x + y"

    상편 794p 위에서 2번째 줄, 위에서 4번째 줄
    다섯 가지 테스트 함수 각각을 순서대로 천만번 실행한 결과에 대한 -> 다섯 가지 테스트 함수 각각이 순서대로 천만개의 산출을 실행한
    총 2500만번의 산출이 발생한다 -> 총 2억 5천만번의 산출이 발생한다

    상편 823p 밑에서 3번째 줄
    최신 버전 파이썬에서는...
    최신 버전 파이썬은 이런 실수를 피하도록 하고자 앞 예제에서 보이는 것처럼 보다 구체적인 "unbound local" 에러 메시지를 보여주도록 개선했다.

    상편 840p 위에서 6번째 줄
    모듈 파일도 코드 파일이긴 하지만 직접 -> 모듈 파일도 코드 파일이긴 하지만 "일반적으로" 직접

    상편 842p 위에서 7번째 줄
    임포트의 표기법은 -> 임포트의 개념은

    상편 844p 밑에서 9번째 줄
    파일 수정 횟수와 -> 파일 수정 시간과

    상편 849p 밑에서 2번째 줄
    site-package 홈 -> site-packages 홈

    상편 851p 밑에서 12번째 줄
    서드파티 확장 기능이 설치된 곳에서는 -> 보통 서드파티 확장 기능이 설치되는

    상편 856p 부연 설명 부분의 위에서 2번째 줄
    파이썬 3.6의 'What's New?' -> 파이썬 3.3의 'What's New?'

    상편 857p의 부연 설명 부분의 위에서 4번째 줄
    setupa.py -> setup.py

    상편 862p의 밑에서 7번째 줄
    실제로, 패키지 임포트(...)에서 사용되는 모듈 파일의 이름과 디렉터리의 이름 모두
    ->
    실제로, 모듈 파일의 이름과 패키지 임포트(...)에서 사용되는 디렉터리의 이름 모두

    상편 865p 밑에서 4번째 줄
    파일 또는 프로세스당 -> 프로세스당 각 파일을

    상편 873p 밑에서 7번째 줄, 밑에서 2번째 줄
    모듈 객체를 생성한다. -> 모듈 속성을 생성한다.
    객체를 조회하는 것이지만, -> 뷰 객체(view object)를 조회하는 것이지만,

    상편 875p 코드의 마지막 주석
    다른 모듈에서 이름을 볼 수 없음 -> 다른 모듈에 있는 이름을 볼 수 없음

    상편 877p 밑에서 3번째 줄
    mod1과 mod2 내부에서 -> mod1에서 mod2는

    상편 879p 코드에서 밑에서 3번째 줄
    d -> 삭제

    상편 882p 위에서 5번째 줄
    리로드 연산은 이름들을 매우 이상한 -> from에 대한 리로드 연산은 이름들을 매우 이상한

    상편 886p 밑에서 9번째 줄
    디렉리가있으며, -> 디렉터리가 있으며,

    상편 905p 위에서 6번째 줄
    절대 임포트문 모든 디렉터리를 sys.path의 패키지 루트 항목 아래로
    ->
    절대 임포트문은 sys.path의 패키지 루트 항목 아래에 있는 모든 디렉터리를

    상편 905p 첫번째 코드의 주석
    시스템 컨테이너는 sys.path상에만 -> system을 포함하는 디렉터리만 sys.path에

    상편 921p 밑에서 7번째 줄
    결쳐 나눠지고, -> 걸쳐 나눠지고,

    상편 923p 위에서 2번째 줄, 위에서 10번째 줄
    반복 객체로 시작하는 -> 반복 객체로 설정되는
    디렉터리들과 일종의 가상 연결이 이루어진다. -> 디렉터리들에 대한 일종의 가상 연결(concatenation)이 된다.

    상편 944p 위에서 8번째 줄
    입력값을 위한 셸 유저를 띄우기 위해 -> 입력값을 셸 사용자로부터 입력받기 위해

    상편 945p 위에서 1번째 줄
    텍스트 문자열에서의 순서(정수)를 가리키는 유니코드 코드
    ->
    텍스트 문자열에서의 문자를 가리키는 유니코드 코드 포인트 서수(정수)