전문가를 위한 파이썬: 간단하고, 명료하고, 효율적인 파이썬 프로그래밍 (파이썬 3 버전 기반)

Table of contents

1. 전문가를 위한 파이썬
   1. 지은이·옮긴이 소개
   2. 추천의 글
   3. 이 책에 대하여 (1/2)
   4. 이 책에 대하여 (2/2)
   5. 감사의 글
   6. 목차 (1/4)
   7. 목차 (2/4)
   8. 목차 (3/4)
   9. 목차 (4/4)
2. Part I 들어가며
   1. CHAPTER 1 파이썬 데이터 모델
      1. 1.1 파이썬 카드 한 벌
      2. 1.2 특별 메서드는 어떻게 사용되나?
         1. 1.2.1 수치형 흉내 내기
         2. 1.2.2 문자열 표현
         3. 1.2.3 산술 연산자
         4. 1.2.4 사용자 정의형의 불리언 값
      3. 1.3 특별 메서드 개요
      4. 1.4 왜 len()은 메서드가 아닐까?
      5. 1.5 요약
      6. 1.6 읽을거리
3. Part II 데이터 구조체
   1. CHAPTER 2 시퀀스
      1. 2.1 내장 시퀀스 개요
      2. 2.2 지능형 리스트와 제너레이터 표현식 (1/2)
      3. 2.2 지능형 리스트와 제너레이터 표현식 (2/2)
         1. 2.2.1 지능형 리스트와 가독성
         2. 2.2.2 지능형 리스트와 map()/filter() 비교
         3. 2.2.3 데카르트 곱
         4. 2.2.4 제너레이터 표현식
      4. 2.3 튜플은 단순한 불변 리스트가 아니다 (1/2)
      5. 2.3 튜플은 단순한 불변 리스트가 아니다 (2/2)
         1. 2.3.1 레코드로서의 튜플
         2. 2.3.2 튜플 언패킹
         3. 2.3.3 내포된 튜플 언패킹
         4. 2.3.4 명명된 튜플
         5. 2.3.5 불변 리스트로서의 튜플
      6. 2.4 슬라이싱
         1. 2.4.1 슬라이스와 범위 지정시에 마지막 항목이 포함되지 않는 이유
         2. 2.4.2 슬라이스 객체
         3. 2.4.3 다차원 슬라이싱과 생략 기호
         4. 2.4.4 슬라이스에 할당하기
      7. 2.5 시퀀스에 덧셈과 곱셈 연산자 사용하기
         1. 2.5.1 리스트의 리스트 만들기
      8. 2.6 시퀀스의 복합 할당
         1. 2.6.1 += 복합 할당 퀴즈
      9. 2.7 list.sort()와 sorted() 내장 함수
      10. 2.8 정렬된 시퀀스를 bisect로 관리하기
          1. 2.8.1 bisect()로 검색하기
          2. 2.8.2 bisect.insort()로 삽입하기
      11. 2.9 리스트가 답이 아닐 때 (1/3)
      12. 2.9 리스트가 답이 아닐 때 (2/3)
      13. 2.9 리스트가 답이 아닐 때 (3/3)
          1. 2.9.1 배열
          2. 2.9.2 메모리 뷰
          3. 2.9.3 NumPy와 SciPy
          4. 2.9.4 덱 및 기타 큐
      14. 2.10 요약
      15. 2.11 읽을거리 (1/2)
      16. 2.11 읽을거리 (2/2)
   2. CHAPTER 3 딕셔너리와 집합
      1. 3.1 일반적인 매핑형
      2. 3.2 지능형 딕셔너리
      3. 3.3 공통적인 매핑 메서드
         1. 3.3.1 존재하지 않는 키를 setdefault()로 처리하기
      4. 3.4 융통성 있게 키를 조회하는 매핑
         1. 3.4.1 defaultdict: 존재하지 않는 키에 대한 또 다른 처리
         2. 3.4.2 __missing__() 메서드
      5. 3.5 그 외 매핑형
      6. 3.6 UserDict 상속하기
      7. 3.7 불변 매핑
      8. 3.8 집합 이론 (1/2)
      9. 3.8 집합 이론 (2/2)
         1. 3.8.1 집합 리터럴
         2. 3.8.2 지능형 집합
         3. 3.8.3 집합 연산
      10. 3.9 dict와 set의 내부 구조 (1/2)
      11. 3.9 dict와 set의 내부 구조 (2/2)
          1. 3.9.1 성능 실험
          2. 3.9.2 딕셔너리 안의 해시 테이블
          3. 3.9.3 dict 작동 방식에 의한 영향
          4. 3.9.4 집합의 작동 방식 - 현실적으로 미치는 영향
      12. 3.10 요약
      13. 3.11 읽을거리
   3. CHAPTER 4 텍스트와 바이트
      1. 4.1 문자 문제
      2. 4.2 바이트에 대한 기본 지식
         1. 4.2.1 구조체와 메모리 뷰
      3. 4.3 기본 인코더/디코더
      4. 4.4 인코딩/디코딩 문제 이해하기 (1/2)
      5. 4.4 인코딩/디코딩 문제 이해하기 (2/2)
         1. 4.4.1 UnicodeEncodeError 처리하기
         2. 4.4.2 UnicodeDecodeError 처리하기
         3. 4.4.3 예상과 달리 인코딩된 모듈을 로딩할 때 발생하는 SyntaxError
         4. 4.4.4 바이트 시퀀스의 인코딩 방식을 알아내는 방법
         5. 4.4.5 BOM: 유용한 깨진 문자
      6. 4.5 텍스트 파일 다루기 (1/2)
      7. 4.5 텍스트 파일 다루기 (2/2)
         1. 4.5.1 기본 인코딩 설정: 정신 나간 거 아냐?
      8. 4.6 제대로 비교하기 위해 유니코드 정규화하기 (1/2)
      9. 4.6 제대로 비교하기 위해 유니코드 정규화하기 (2/2)
         1. 4.6.1 케이스 폴딩
         2. 4.6.2 정규화된 텍스트 매칭을 위한 유틸리티 함수
         3. 4.6.3 극단적인 ‘정규화’: 발음 구별 기호 제거하기
      10. 4.7 유니코드 텍스트 정렬하기
          1. 4.7.1 유니코드 대조 알고리즘을 이용한 정렬
      11. 4.8 유니코드 데이터베이스
      12. 4.9 이중 모드 str 및 bytes API
          1. 4.9.1 정규 표현식에서의 str과 bytes
          2. 4.9.2 os 모듈 함수에서 str과 bytes
      13. 4.10 요약
      14. 4.11 읽을거리 (1/2)
      15. 4.11 읽을거리 (2/2)
4. Part III 객체로서의 함수
   1. CHAPTER 5 일급 함수
      1. 5.1 함수를 객체처럼 다루기
      2. 5.2 고위 함수
         1. 5.2.1 map(), filter(), reduce()의 대안
      3. 5.3 익명 함수
      4. 5.4 일곱 가지 맛의 콜러블 객체
      5. 5.5 사용자 정의 콜러블형
      6. 5.6 함수 인트로스펙션
      7. 5.7 위치 매개변수에서 키워드 전용 매개변수까지
      8. 5.8 매개변수에 대한 정보 읽기
      9. 5.9 함수 애너테이션
      10. 5.10 함수형 프로그래밍을 위한 패키지 (1/2)
      11. 5.10 함수형 프로그래밍을 위한 패키지 (2/2)
          1. 5.10.1 operator 모듈
          2. 5.10.2 functools.partial()로 인수 고정하기
      12. 5.11 요약
      13. 5.12 읽을거리
   2. CHAPTER 6 일급 함수 디자인 패턴
      1. 6.1 사례: 전략 패턴의 리팩토링 (1/3)
      2. 6.1 사례: 전략 패턴의 리팩토링 (2/3)
      3. 6.1 사례: 전략 패턴의 리팩토링 (3/3)
         1. 6.1.1 고전적인 전략
         2. 6.1.2 함수지향 전략
         3. 6.1.3 최선의 전략 선택하기: 단순한 접근법
         4. 6.1.4 모듈에서 전략 찾기
      4. 6.2 명령
      5. 6.3 요약
      6. 6.4 읽을거리
   3. CHAPTER 7 함수 데커레이터와 클로저
      1. 7.1 데커레이터 기본 지식
      2. 7.2 파이썬이 데커레이터를 실행하는 시점
      3. 7.3 데커레이터로 개선한 전략 패턴
      4. 7.4 변수 범위 규칙
      5. 7.5 클로저
      6. 7.6 nonlocal 선언
      7. 7.7 간단한 데커레이터 구현하기
         1. 7.7.1 작동 과정
      8. 7.8 표준 라이브러리에서 제공하는 데커레이터 (1/2)
      9. 7.8 표준 라이브러리에서 제공하는 데커레이터 (2/2)
         1. 7.8.1 functools.lru_cache()를 이용한 메모이제이션
         2. 7.8.2 단일 디스패치를 이용한 범용 함수
      10. 7.9 누적된 데커레이터
      11. 7.10 매개변수화된 데커레이터 (1/2)
      12. 7.10 매개변수화된 데커레이터 (2/2)
          1. 7.10.1 매개변수화된 등록 데커레이터
          2. 7.10.2 매개변수화된 clock 데커레이터
      13. 7.11 요약
      14. 7.12 읽을거리 (1/2)
      15. 7.12 읽을거리 (2/2)
5. PartIV
   1. CHAPTER 8 객체 참조, 가변성, 재활용
      1. 8.1 변수는 상자가 아니다
      2. 8.2 정체성, 동질성, 별명
         1. 8.2.1 == 연산자와 is 연산자 간의 선택
         2. 8.2.2 튜플의 상대적 불변성
      3. 8.3 기본 복사는 얕은 복사
         1. 8.3.1 객체의 깊은 복사와 얕은 복사
      4. 8.4 참조로서의 함수 매개변수 (1/2)
      5. 8.4 참조로서의 함수 매개변수 (2/2)
         1. 8.4.1 가변형을 매개변수 기본값으로 사용하기: 좋지 않은 생각
         2. 8.4.2 가변 매개변수에 대한 방어적 프로그래밍
      6. 8.5 del과 가비지 컬렉션
      7. 8.6 약한 참조
         1. 8.6.1 WeakValueDictionary 촌극
         2. 8.6.2 약한 참조의 한계
      8. 8.7 파이썬의 특이한 불변형 처리법
      9. 8.8 요약
      10. 8.9 읽을거리
   2. CHAPTER 9 파이썬스러운 객체
      1. 9.1 객체 표현
      2. 9.2 벡터 클래스의 부활
      3. 9.3 대안 생성자
      4. 9.4 @classmethod와 @staticmethod
      5. 9.5 포맷된 출력
      6. 9.6 해시 가능한 Vector2d (1/2)
      7. 9.6 해시 가능한 Vector2d (2/2)
      8. 9.7 파이썬에서의 비공개 속성과 보호된 속성
      9. 9.8 __slots__ 클래스 속성으로 공간 절약하기
         1. 9.8.1 __slots__를 사용할 때 주의할 점
      10. 9.9 클래스 속성 오버라이드
      11. 9.10 요약
      12. 9.11 읽을거리
   3. CHAPTER 10 시퀀스 해킹, 해시, 슬라이스
      1. 10.1 Vector: 사용자 정의 시퀀스형
      2. 10.2 Vector 버전 #1: Vector2d 호환
      3. 10.3 프로토콜과 덕 타이핑
      4. 10.4 Vector 버전 #2: 슬라이스 가능한 시퀀스
         1. 10.4.1 슬라이싱 작동 방식
         2. 10.4.2 슬라이스를 인식하는 __getitem__()
      5. 10.5 Vector 버전 #3: 동적 속성 접근
      6. 10.6 Vector 버전 #4: 해싱 및 더 빠른 == (1/2)
      7. 10.6 Vector 버전 #4: 해싱 및 더 빠른 == (2/2)
      8. 10.7 Vector 버전 #5: 포매팅 (1/2)
      9. 10.7 Vector 버전 #5: 포매팅 (2/2)
      10. 10.8 요약
      11. 10.9 읽을거리 (1/2)
      12. 10.9 읽을거리 (2/2)
   4. CHAPTER 11 인터페이스: 프로토콜에서 ABC까지
      1. 11.1 파이썬 문화에서의 인터페이스와 프로토콜
      2. 11.2 파이썬은 시퀀스를 찾아낸다
      3. 11.3 런타임에 프로토콜을 구현하는 멍키 패칭
      4. 11.4 알렉스 마르텔리의 물새 (1/2)
      5. 11.4 알렉스 마르텔리의 물새 (2/2)
      6. 11.5 ABC 상속하기
      7. 11.6 표준 라이브러리의 ABC
         1. 11.6.1 collections.abc의 ABC
         2. 11.6.2 ABC의 숫자탑
      8. 11.7 ABC의 정의와 사용 (1/3)
      9. 11.7 ABC의 정의와 사용 (2/3)
      10. 11.7 ABC의 정의와 사용 (3/3)
          1. 11.7.1 ABC 상세 구문
          2. 11.7.2 Tombola ABC 상속하기
          3. 11.7.3 Tombola의 가상 서브클래스
      11. 11.8 Tombola 서브클래스 테스트 방법
      12. 11.9 register()의 실제 용법
      13. 11.10 오리처럼 행동할 수 있는 거위
      14. 11.11 요약
      15. 11.12 읽을거리 (1/2)
      16. 11.12 읽을거리 (2/2)
   5. CHAPTER 12 내장 자료형 상속과 다중 상속
      1. 12.1 내장 자료형의 상속은 까다롭다
      2. 12.2 다중 상속과 메서드 결정 순서 (1/2)
      3. 12.2 다중 상속과 메서드 결정 순서 (2/2)
      4. 12.3 실세계에서의 다중 상속
      5. 12.4 다중 상속 다루기
         1. 12.4.1 Tkinter: 장점, 단점, 그리고 보기 흉함
      6. 12.5 최신 사례: 장고 제너릭 뷰의 믹스인
      7. 12.6 요약
      8. 12.7 읽을거리
   6. CHAPTER 13 연산자 오버로딩: 제대로 하기
      1. 13.1 연산자 오버로딩 기본 지식
      2. 13.2 단항 연산자
      3. 13.3 벡터를 더하기 위해 + 오버로딩하기 (1/2)
      4. 13.3 벡터를 더하기 위해 + 오버로딩하기 (2/2)
      5. 13.4 벡터를 스칼라와 곱하기 위해 * 오버로딩하기
      6. 13.5 향상된 비교 연산자
      7. 13.6 복합 할당 할당자
      8. 13.7 요약
      9. 13.8 읽을거리 (1/2)
      10. 13.8 읽을거리 (2/2)
6. PartV
   1. CHAPTER 14 반복형, 반복자, 제너레이터
      1. 14.1 Sentence 버전 #1: 단어 시퀀스
         1. 14.1.1 Sequence가 반복 가능한 이유: iter() 함수
      2. 14.2 반복형과 반복자
      3. 14.3 Sentence 버전 #2: 고전적인 반복자
         1. 14.3.1 Sentence를 반복자로 만들기: 좋지 않은 생각
      4. 14.4 Sentence 버전 #3: 제너레이터 함수
         1. 14.4.1 제너레이터 함수의 작동 방식
      5. 14.5 Sentence 버전 #4: 느긋한 구현
      6. 14.6 Sentence 버전 #5: 제너레이터 표현식
      7. 14.7 제너레이터 표현식: 언제 사용하나?
      8. 14.8 또 다른 예제: 등차수열 제너레이터
         1. 14.8.1 itertools를 이용한 등차수열
      9. 14.9 표준 라이브러리의 제너레이터 함수 (1/2)
      10. 14.9 표준 라이브러리의 제너레이터 함수 (2/2)
      11. 14.10 파이썬 3.3의 새로운 구문: yield from
      12. 14.11 반복형을 리듀스하는 함수
      13. 14.12 iter() 함수 들여다보기
      14. 14.13 사례 연구: 데이터베이스 변환 유틸리티 안의 제너레이터
      15. 14.14 코루틴으로서의 제너레이터
      16. 14.15 요약
      17. 14.16 읽을거리 (1/2)
      18. 14.16 읽을거리 (2/2)
   2. CHAPTER 15 콘텍스트 관리자와 else 블록
      1. 15.1 이것 다음에 저것: if 문 이외에서의 else 블록
      2. 15.2 콘텍스트 관리자와 with 블록
      3. 15.3 contextlib 유틸리티
      4. 15.4 @contextmanager 사용하기
      5. 15.5 요약
      6. 15.6 읽을거리
   3. CHAPTER 16 코루틴
      1. 16.1 코루틴은 제너레이터에서 어떻게 진화했는가?
      2. 16.2 코루틴으로 사용되는 제너레이터의 기본 동작
      3. 16.3 예제: 이동 평균을 계산하는 코루틴
      4. 16.4 코루틴을 기동하기 위한 데커레이터
      5. 16.5 코루틴 종료와 예외 처리
      6. 16.6 코루틴에서 값 반환하기
      7. 16.7 yield from 사용하기 (1/2)
      8. 16.7 yield from 사용하기 (2/2)
      9. 16.8 yield from의 의미 (1/2)
      10. 16.8 yield from의 의미 (2/2)
      11. 16.9 사용 사례: 이산 이벤트 시뮬레이션을 위한 코루틴 (1/3)
      12. 16.9 사용 사례: 이산 이벤트 시뮬레이션을 위한 코루틴 (2/3)
      13. 16.9 사용 사례: 이산 이벤트 시뮬레이션을 위한 코루틴 (3/3)
          1. 16.9.1 이산 이벤트 시뮬레이션에 대해
          2. 16.9.2 택시 집단 시뮬레이션
      14. 16.10 요약
      15. 16.11 읽을거리 (1/2)
      16. 16.11 읽을거리 (2/2)
   4. CHAPTER 17 Future를 이용한 동시성
      1. 17.1 예제: 세 가지 스타일의 웹 내려받기 (1/2)
      2. 17.1 예제: 세 가지 스타일의 웹 내려받기 (2/2)
         1. 17.1.1 순차 내려받기 스크립트
         2. 17.1.2 concurrent.futures로 내려받기
         3. 17.1.3 Future는 어디에 있나?
      3. 17.2 블로킹 I/O와 GIL
      4. 17.3 concurrent.futures로 프로세스 실행하기
      5. 17.4 Executor.map() 실험
      6. 17.5 진행 상황 출력하고 에러를 처리하며 내려받기 (1/3)
      7. 17.5 진행 상황 출력하고 에러를 처리하며 내려받기 (2/3)
      8. 17.5 진행 상황 출력하고 에러를 처리하며 내려받기 (3/3)
         1. 17.5.1 flags2 예제에서의 에러 처리
         2. 17.5.2 futures.as_completed() 사용하기
         3. 17.5.3 스레드 및 멀티프로세스의 대안
      9. 17.6 요약
      10. 17.7 읽을거리
   5. CHAPTER 18 asyncio를 이용한 동시성
      1. 18.1 스레드와 코루틴 비교 (1/2)
      2. 18.1 스레드와 코루틴 비교 (2/2)
         1. 18.1.1 asyncio.Future: 논블로킹 설계
         2. 18.1.2 Future, Task, 코루틴에서 생성하기
      3. 18.2 asyncio와 aiohttp로 내려받기
      4. 18.3 블로킹 호출을 에둘러 실행하기
      5. 18.4 asyncio 내려받기 스크립트 개선 (1/2)
      6. 18.4 asyncio 내려받기 스크립트 개선 (2/2)
         1. 18.4.1 asyncio.as_completed() 사용하기
         2. 18.4.2 Executor를 이용해서 이벤트 루프 블로킹 피하기
      7. 18.5 콜백에서 Future와 코루틴으로 (1/2)
      8. 18.5 콜백에서 Future와 코루틴으로 (2/2)
         1. 18.5.1 한 번 내려받을 때 여러 가지 요청하기
      9. 18.6 asyncio 서버 작성 (1/3)
      10. 18.6 asyncio 서버 작성 (2/3)
      11. 18.6 asyncio 서버 작성 (3/3)
          1. 18.6.1 asyncio TCP 서버
          2. 18.6.2 aiohttp 웹 서버
          3. 18.6.3 동시성을 향상시키는 똑똑한 클라이언트
      12. 18.7 요약
      13. 18.8 읽을거리 (1/2)
      14. 18.8 읽을거리 (2/2)
7. Part VI 메타프로그래밍
   1. CHAPTER 19 동적 속성과 프로퍼티
      1. 19.1 동적 속성을 이용한 데이터 랭글링 (1/5)
      2. 19.1 동적 속성을 이용한 데이터 랭글링 (2/5)
      3. 19.1 동적 속성을 이용한 데이터 랭글링 (3/5)
      4. 19.1 동적 속성을 이용한 데이터 랭글링 (4/5)
      5. 19.1 동적 속성을 이용한 데이터 랭글링 (5/5)
         1. 19.1.1 동적 속성을 이용해서 JSON과 유사한 데이터 둘러보기
         2. 19.1.2 잘못된 속성명 문제
         3. 19.1.3 __new__()를 이용한 융통성 있는 객체 생성
         4. 19.1.4 shelve를 이용해서 OSCON 피드 구조 변경하기
         5. 19.1.5 프로퍼티를 이용해서 연결된 레코드 읽기
      6. 19.2 속성을 검증하기 위해 프로퍼티 사용하기
         1. 19.2.1 LineItem 버전 #1: 주문 항목 클래스
         2. 19.2.2 LineItem 버전 #2: 검증하는 프로퍼티
      7. 19.3 프로퍼티 제대로 알아보기 (1/2)
      8. 19.3 프로퍼티 제대로 알아보기 (2/2)
         1. 19.3.1 객체 속성을 가리는 프로퍼티
         2. 19.3.2 프로퍼티 문서화
      9. 19.4 프로퍼티 팩토리 구현하기
      10. 19.5 속성 제거 처리하기
      11. 19.6 속성을 처리하는 핵심 속성 및 함수
          1. 19.6.1 속성 처리에 영향을 주는 특별 속성
          2. 19.6.2 속성을 처리하는 내장 함수
          3. 19.6.3 속성을 처리하는 특별 메서드
      12. 19.7 요약
      13. 19.8 읽을거리 (1/2)
      14. 19.8 읽을거리 (2/2)
   2. CHAPTER 20 속성 디스크립터
      1. 20.1 디스크립터 예: 속성 검증 (1/4)
      2. 20.1 디스크립터 예: 속성 검증 (2/4)
      3. 20.1 디스크립터 예: 속성 검증 (3/4)
      4. 20.1 디스크립터 예: 속성 검증 (4/4)
         1. 20.1.1 LineItem 버전 #3: 간단한 디스크립터
         2. 20.1.2 LineItem 버전 #4: 자동 저장소 속성명
         3. 20.1.3 LineItem 버전 #5: 새로운 디스크립터형
      5. 20.2 오버라이딩 디스크립터와 논오버라이딩 디스크립터 (1/2)
      6. 20.2 오버라이딩 디스크립터와 논오버라이딩 디스크립터 (2/2)
         1. 20.2.1 오버라이딩 디스크립터
         2. 20.2.2 __get__()이 없는 오버라이딩 디스크립터
         3. 20.2.3 논오버라이딩 디스크립터
         4. 20.2.4 클래스 안에서 디스크립터 덮어쓰기
      7. 20.3 메서드는 디스크립터
      8. 20.4 디스크립터 사용에 대한 조언
      9. 20.5 디스크립터의 문서화 문자열과 관리 대상 속성의 삭제
      10. 20.6 요약
      11. 20.7 읽을거리
   3. CHAPTER 21 클래스 메타프로그래밍
      1. 21.1 클래스 팩토리
      2. 21.2 디스크립터를 커스터마이즈하기 위한 클래스 데커레이터
      3. 21.3 임포트 타임과 런타임
         1. 21.3.1 코드 평가 시점 연습문제
      4. 21.4 메타클래스 기본 지식 (1/2)
      5. 21.4 메타클래스 기본 지식 (2/2)
         1. 21.4.1 메타클래스 평가 시점 연습문제
      6. 21.5 디스크립터를 커스터마이즈하기 위한 메타클래스
      7. 21.6 메타클래스 __prepare__() 특별 메서드
      8. 21.7 객체로서의 클래스
      9. 21.8 요약
      10. 21.9 읽을거리
8. 부록 A 지원 스크립트 (1/7)
9. 부록 A 지원 스크립트 (2/7)
10. 부록 A 지원 스크립트 (3/7)
11. 부록 A 지원 스크립트 (4/7)
12. 부록 A 지원 스크립트 (5/7)
13. 부록 A 지원 스크립트 (6/7)
14. 부록 A 지원 스크립트 (7/7)
15. 부록 B 파이썬 용어 (1/4)
16. 부록 B 파이썬 용어 (2/4)
17. 부록 B 파이썬 용어 (3/4)
18. 부록 B 파이썬 용어 (4/4)
19. 책을 마치며
20. 찾아보기