파이썬 설명서 목차
******************

* 파이썬의 새로운 기능

  * What's New In Python 3.12

    * Summary -- Release highlights

    * New Features

      * PEP 695: Type Parameter Syntax

      * PEP 701: Syntactic formalization of f-strings

      * PEP 684: A Per-Interpreter GIL

      * PEP 669: Low impact monitoring for CPython

      * PEP 688: Making the buffer protocol accessible in Python

      * PEP 709: Comprehension inlining

      * Improved Error Messages

    * New Features Related to Type Hints

      * PEP 692: Using "TypedDict" for more precise "**kwargs" typing

      * PEP 698: Override Decorator for Static Typing

    * Other Language Changes

    * New Modules

    * Improved Modules

      * array

      * asyncio

      * calendar

      * csv

      * dis

      * fractions

      * importlib.resources

      * inspect

      * itertools

      * math

      * os

      * os.path

      * pathlib

      * pdb

      * random

      * shutil

      * sqlite3

      * statistics

      * sys

      * tempfile

      * threading

      * tkinter

      * tokenize

      * types

      * typing

      * unicodedata

      * unittest

      * uuid

    * Optimizations

    * CPython bytecode changes

    * Demos and Tools

    * Deprecated

      * Pending Removal in Python 3.13

      * Pending Removal in Python 3.14

      * Pending Removal in Python 3.15

      * Pending Removal in Python 3.16

      * Pending Removal in Future Versions

    * Removed

      * asynchat and asyncore

      * configparser

      * distutils

      * ensurepip

      * enum

      * ftplib

      * gzip

      * hashlib

      * importlib

      * imp

      * io

      * locale

      * smtpd

      * sqlite3

      * ssl

      * unittest

      * webbrowser

      * xml.etree.ElementTree

      * zipimport

      * Others

    * Porting to Python 3.12

      * Changes in the Python API

    * Build Changes

    * C API Changes

      * New Features

      * Porting to Python 3.12

      * Deprecated

        * Pending Removal in Python 3.14

        * Pending Removal in Python 3.15

        * Pending Removal in Future Versions

      * Removed

    * Notable changes in 3.12.4

      * ipaddress

    * Notable changes in 3.12.5

      * email

    * Notable changes in 3.12.6

      * email

    * Notable changes in 3.12.8

      * sys

  * What's New In Python 3.11

    * Summary -- Release highlights

    * New Features

      * PEP 657: Fine-grained error locations in tracebacks

      * PEP 654: Exception Groups and "except*"

      * PEP 678: Exceptions can be enriched with notes

      * Windows "py.exe" launcher improvements

    * New Features Related to Type Hints

      * PEP 646: Variadic generics

      * PEP 655: Marking individual "TypedDict" items as required or
        not-required

      * PEP 673: "Self" type

      * PEP 675: Arbitrary literal string type

      * PEP 681: Data class transforms

      * PEP 563 may not be the future

    * Other Language Changes

    * Other CPython Implementation Changes

    * New Modules

    * Improved Modules

      * asyncio

      * contextlib

      * dataclasses

      * datetime

      * enum

      * fcntl

      * fractions

      * functools

      * gzip

      * hashlib

      * IDLE and idlelib

      * inspect

      * locale

      * logging

      * math

      * operator

      * os

      * pathlib

      * re

      * shutil

      * socket

      * sqlite3

      * string

      * sys

      * sysconfig

      * tempfile

      * threading

      * time

      * tkinter

      * traceback

      * typing

      * unicodedata

      * unittest

      * venv

      * warnings

      * zipfile

    * Optimizations

    * Faster CPython

      * Faster Startup

        * Frozen imports / Static code objects

      * Faster Runtime

        * Cheaper, lazy Python frames

        * Inlined Python function calls

        * PEP 659: Specializing Adaptive Interpreter

      * Misc

      * FAQ

        * How should I write my code to utilize these speedups?

        * Will CPython 3.11 use more memory?

        * I don't see any speedups in my workload. Why?

        * Is there a JIT compiler?

      * About

    * CPython bytecode changes

      * New opcodes

      * Replaced opcodes

      * Changed/removed opcodes

    * Deprecated

      * Language/Builtins

      * Modules

      * Standard Library

    * Pending Removal in Python 3.12

    * Removed

    * Porting to Python 3.11

    * Build Changes

    * C API Changes

      * New Features

      * Porting to Python 3.11

      * Deprecated

      * Pending Removal in Python 3.12

      * Removed

    * Notable changes in 3.11.4

      * tarfile

    * Notable changes in 3.11.5

      * OpenSSL

  * What's New In Python 3.10

    * Summary -- Release highlights

    * New Features

      * Parenthesized context managers

      * Better error messages

        * SyntaxErrors

        * IndentationErrors

        * AttributeErrors

        * NameErrors

      * PEP 626: Precise line numbers for debugging and other tools

      * PEP 634: Structural Pattern Matching

        * Syntax and operations

        * Declarative approach

        * Simple pattern: match to a literal

          * Behavior without the wildcard

        * Patterns with a literal and variable

        * Patterns and classes

          * Patterns with positional parameters

        * Nested patterns

        * Complex patterns and the wildcard

        * Guard

        * Other Key Features

      * Optional "EncodingWarning" and "encoding="locale"" option

    * New Features Related to Type Hints

      * PEP 604: New Type Union Operator

      * PEP 612: Parameter Specification Variables

      * PEP 613: TypeAlias

      * PEP 647: User-Defined Type Guards

    * Other Language Changes

    * New Modules

    * Improved Modules

      * asyncio

      * argparse

      * array

      * asynchat, asyncore, smtpd

      * base64

      * bdb

      * bisect

      * codecs

      * collections.abc

      * contextlib

      * curses

      * dataclasses

        * __slots__

        * Keyword-only fields

      * distutils

      * doctest

      * encodings

      * enum

      * fileinput

      * faulthandler

      * gc

      * glob

      * hashlib

      * hmac

      * IDLE and idlelib

      * importlib.metadata

      * inspect

      * itertools

      * linecache

      * os

      * os.path

      * pathlib

      * platform

      * pprint

      * py_compile

      * pyclbr

      * shelve

      * statistics

      * site

      * socket

      * ssl

      * sqlite3

      * sys

      * _thread

      * threading

      * traceback

      * types

      * typing

      * unittest

      * urllib.parse

      * xml

      * zipimport

    * Optimizations

    * Deprecated

    * Removed

    * Porting to Python 3.10

      * Changes in the Python syntax

      * Changes in the Python API

      * Changes in the C API

    * CPython bytecode changes

    * Build Changes

    * C API Changes

      * PEP 652: Maintaining the Stable ABI

      * New Features

      * Porting to Python 3.10

      * Deprecated

      * Removed

    * Notable security feature in 3.10.7

    * Notable security feature in 3.10.8

    * Notable changes in 3.10.12

      * tarfile

  * 파이썬 3.9의 새로운 기능

    * 요약 -- 배포 주요 사항

    * 여러분의 코드에서 DeprecationWarning을 확인해야합니다

    * 새로운 기능

      * 딕셔너리 병합과 업데이트 연산자

      * 접두사와 접미사를 제거하는 새로운 문자열 메서드

      * 표준 컬렉션의 형 힌트 제네릭

      * 새로운 구문 분석기

    * 기타 언어 변경

    * 새 모듈

      * zoneinfo

      * graphlib

    * 개선된 모듈

      * ast

      * asyncio

      * compileall

      * concurrent.futures

      * curses

      * datetime

      * distutils

      * fcntl

      * ftplib

      * gc

      * hashlib

      * http

      * IDLE과 idlelib

      * imaplib

      * importlib

      * inspect

      * ipaddress

      * math

      * multiprocessing

      * nntplib

      * os

      * pathlib

      * pdb

      * poplib

      * pprint

      * pydoc

      * random

      * signal

      * smtplib

      * socket

      * time

      * sys

      * tracemalloc

      * typing

      * unicodedata

      * venv

      * xml

    * 최적화

    * 폐지

    * 제거

    * 파이썬 3.9로 이식하기

      * 파이썬 API의 변경

      * C API의 변경

      * CPython 바이트 코드 변경

    * 빌드 변경

    * C API 변경

      * 새로운 기능

      * 파이썬 3.9로 이식하기

      * 제거

    * 파이썬 3.9.1의 주목할만한 변경 사항

      * typing

      * macOS 11.0 (Big Sur) 및 Apple Silicon Mac 지원

    * 파이썬 3.9.2의 주목할만한 변경 사항

      * collections.abc

      * urllib.parse

    * 파이썬 3.9.3의 주목할만한 변경 사항

    * Notable changes in Python 3.9.5

      * urllib.parse

    * Notable security feature in 3.9.14

    * Notable changes in 3.9.17

      * tarfile

  * 파이썬 3.8의 새로운 기능

    * 요약 -- 배포 주요 사항

    * 새로운 기능

      * 대입 표현식

      * 위치 전용 매개 변수

      * 컴파일된 바이트 코드 파일을 위한 병렬 파일 시스템 캐시

      * 디버그 빌드는 릴리스 빌드와 같은 ABI를 사용합니다.

      * f-문자열은 스스로 설명하는 표현식과 디버깅을 위해 =를 지원합니
        다.

      * PEP 578: 파이썬 런타임 감사 훅

      * PEP 587: 파이썬 초기화 구성

      * PEP 590: 벡터콜: CPython을 위한 빠른 호출 프로토콜

      * 아웃 오브 밴드 데이터 버퍼를 사용하는 피클 프로토콜 5

    * 기타 언어 변경

    * 새 모듈

    * 개선된 모듈

      * ast

      * asyncio

      * builtins

      * collections

      * cProfile

      * csv

      * curses

      * ctypes

      * datetime

      * functools

      * gc

      * gettext

      * gzip

      * IDLE과 idlelib

      * inspect

      * io

      * itertools

      * json.tool

      * logging

      * math

      * mmap

      * multiprocessing

      * os

      * os.path

      * pathlib

      * pickle

      * plistlib

      * pprint

      * py_compile

      * shlex

      * shutil

      * socket

      * ssl

      * statistics

      * sys

      * tarfile

      * threading

      * tokenize

      * tkinter

      * time

      * typing

      * unicodedata

      * unittest

      * venv

      * weakref

      * xml

      * xmlrpc

    * 최적화

    * 빌드와 C API 변경

    * 폐지

    * API 및 기능 제거

    * 파이썬 3.8로 이식하기

      * 파이썬 동작의 변경

      * 파이썬 API의 변경

      * C API의 변경

      * CPython 바이트 코드 변경

      * 데모와 도구

    * 파이썬 3.8.1의 주목할만한 변경 사항

    * Notable changes in Python 3.8.2

    * Notable changes in Python 3.8.3

    * 파이썬 3.8.8의 주목할만한 변경 사항

    * Notable changes in Python 3.8.9

    * Notable changes in Python 3.8.10

      * macOS 11.0 (Big Sur) and Apple Silicon Mac support

    * Notable changes in Python 3.8.10

      * urllib.parse

    * Notable changes in Python 3.8.12

      * 파이썬 API의 변경

    * Notable security feature in 3.8.14

    * Notable changes in 3.8.17

      * tarfile

  * 파이썬 3.7의 새로운 기능

    * 요약 -- 배포 주요 사항

    * 새로운 기능

      * PEP 563 : 어노테이션의 지연된 평가

      * PEP 538: 레거시 C 로케일 강제 변경

      * PEP 540: 강제 UTF-8 실행시간 모드

      * PEP 553: 내장 "breakpoint()"

      * PEP 539: 스레드-로컬 저장소를 위한 새로운 C API

      * PEP 562: 모듈 어트리뷰트에 대한 액세스 사용자 정의

      * PEP 564: 나노초 해상도의 새로운 시간 함수

      * PEP 565: "__main__" 의 DeprecationWarning 표시

      * PEP 560: "typing" 모듈과 제네릭 형에 대한 코어 지원

      * PEP 552: 해시 기반 .pyc 파일

      * PEP 545: 파이썬 설명서 번역

      * 파이썬 개발 모드 (-X dev)

    * 기타 언어 변경

    * 새 모듈

      * contextvars

      * dataclasses

      * importlib.resources

    * 개선된 모듈

      * argparse

      * asyncio

      * binascii

      * calendar

      * collections

      * compileall

      * concurrent.futures

      * contextlib

      * cProfile

      * crypt

      * datetime

      * dbm

      * decimal

      * dis

      * distutils

      * enum

      * functools

      * gc

      * hmac

      * http.client

      * http.server

      * idlelib 및 IDLE

      * importlib

      * io

      * ipaddress

      * itertools

      * locale

      * logging

      * math

      * mimetypes

      * msilib

      * multiprocessing

      * os

      * pathlib

      * pdb

      * py_compile

      * pydoc

      * queue

      * re

      * signal

      * socket

      * socketserver

      * sqlite3

      * ssl

      * string

      * subprocess

      * sys

      * time

      * tkinter

      * tracemalloc

      * types

      * unicodedata

      * unittest

      * unittest.mock

      * urllib.parse

      * uu

      * uuid

      * warnings

      * xml

      * xml.etree

      * xmlrpc.server

      * zipapp

      * zipfile

    * C API 변경

    * 빌드 변경

    * 최적화

    * 기타 CPython 구현 변경

    * 폐지된 파이썬 동작

    * 폐지된 파이썬 모듈, 함수 및 메서드

      * aifc

      * asyncio

      * collections

      * dbm

      * enum

      * gettext

      * importlib

      * locale

      * macpath

      * threading

      * socket

      * ssl

      * sunau

      * sys

      * wave

    * 폐지된 C API의 함수 및 형

    * 플랫폼 지원 제거

    * API 및 기능 제거

    * 모듈 제거

    * 윈도우 전용 변경

    * 파이썬 3.7로 이식하기

      * 파이썬 동작의 변경

      * 파이썬 API의 변경

      * C API의 변경

      * CPython 바이트 코드 변경

      * 윈도우 전용 변경

      * 기타 CPython 구현 변경

    * 파이썬 3.7.1의 주목할만한 변경 사항

    * 파이썬 3.7.2의 주목할만한 변경 사항

    * 파이썬 3.7.6의 주목할만한 변경 사항

    * 파이썬 3.7.10의 주목할만한 변경 사항

    * Notable changes in Python 3.7.11

    * Notable security feature in 3.7.14

  * 파이썬 3.6의 새로운 기능

    * 요약 -- 배포 주요 사항

    * 새로운 기능

      * PEP 498: 포맷 문자열 리터럴

      * PEP 526: 변수 어노테이션 문법

      * PEP 515: 숫자 리터럴의 밑줄

      * PEP 525: 비동기 제너레이터

      * PEP 530: 비동기 컴프리헨션

      * PEP 487: 더 간단한 클래스 생성 사용자 정의

      * PEP 487: 디스크립터 프로토콜 향상

      * PEP 519: 파일 시스템 경로 프로토콜 추가

      * PEP 495: 현지 시간 명확성

      * PEP 529: 윈도우 파일 시스템 인코딩을 UTF-8로 변경

      * PEP 528: 윈도우 콘솔 인코딩을 UTF-8로 변경

      * PEP 520: 클래스 어트리뷰트 정의 순서 유지

      * PEP 468: 키워드 인자 순서 유지

      * 새로운 *dict* 구현

      * PEP 523: CPython에 프레임 평가 API 추가

      * PYTHONMALLOC 환경 변수

      * DTrace와 SystemTap 프로브 지원

    * 기타 언어 변경

    * 새로운 모듈

      * secrets

    * 개선된 모듈

      * array

      * ast

      * asyncio

      * Binascii

      * cmath

      * collections

      * concurrent.futures

      * contextlib

      * datetime

      * decimal

      * distutils

      * email

      * encodings

      * enum

      * faulthandler

      * fileinput

      * hashlib

      * http.client

      * idlelib와 IDLE

      * importlib

      * inspect

      * json

      * logging

      * math

      * multiprocessing

      * os

      * pathlib

      * pdb

      * pickle

      * pickletools

      * pydoc

      * random

      * re

      * readline

      * rlcompleter

      * shlex

      * site

      * sqlite3

      * socket

      * socketserver

      * ssl

      * statistics

      * struct

      * subprocess

      * sys

      * telnetlib

      * time

      * timeit

      * tkinter

      * traceback

      * tracemalloc

      * typing

      * unicodedata

      * unittest.mock

      * urllib.request

      * urllib.robotparser

      * venv

      * warnings

      * winreg

      * winsound

      * xmlrpc.client

      * zipfile

      * zlib

    * 최적화

    * 빌드와 C API 변경

    * 기타 개선 사항

    * 폐지

      * 새 키워드

      * 폐지된 파이썬 동작

      * 폐지된 파이썬 모듈, 함수 및 메서드

        * asynchat

        * asyncore

        * dbm

        * distutils

        * grp

        * importlib

        * os

        * re

        * ssl

        * tkinter

        * venv

      * xml

      * C API의 폐지된 함수와 형

      * 폐지된 빌드 옵션

    * 제거

      * API와 기능 제거

    * 파이썬 3.6으로 이식하기

      * 'python' 명령 동작의 변경 사항

      * 파이썬 API의 변경 사항

      * C API의 변경 사항

      * CPython 바이트 코드 변경 사항

    * 파이썬 3.6.2의 주목할만한 변경 사항

      * 새로운 "make regen-all" 빌드 대상

      * "make touch" 빌드 대상 제거

    * 파이썬 3.6.4의 주목할만한 변경 사항

    * 파이썬 3.6.5의 주목할만한 변경 사항

    * 파이썬 3.6.7의 주목할만한 변경 사항

    * 파이썬 3.6.10의 주목할만한 변경 사항

    * 파이썬 3.6.13의 주목할만한 변경 사항

    * Notable changes in Python 3.6.14

  * 파이썬 3.5의 새로운 기능

    * 요약 -- 배포 주요 사항

    * 새로운 기능

      * PEP 492 - async와 await 구문을 사용하는 코루틴

      * PEP 465 - 행렬 곱셈을 위한 전용 중위(infix) 연산자

      * PEP 448 - 추가적인 언 패킹 일반화

      * PEP 461 - bytes와 bytearray를 위한 퍼센트 포매팅 지원

      * PEP 484 - 형 힌트

      * PEP 471 - os.scandir() 함수 -- 더 빠르고 더 나은 디렉터리 이터
        레이터

      * PEP 475: EINTR로 실패한 시스템 호출 재시도

      * PEP 479: 제너레이터 내부에서의 StopIteration 처리 변경

      * PEP 485: 대략적인 동등성을 테스트하는 함수

      * PEP 486: 파이썬 런처가 가상 환경을 인식하도록 만들기

      * PEP 488: PYO 파일 제거

      * PEP 489: 다단계 확장 모듈 초기화

    * 기타 언어 변경

    * 새로운 모듈

      * typing

      * zipapp

    * 개선된 모듈

      * argparse

      * asyncio

      * bz2

      * cgi

      * cmath

      * code

      * collections

      * collections.abc

      * compileall

      * concurrent.futures

      * configparser

      * contextlib

      * csv

      * curses

      * dbm

      * difflib

      * distutils

      * doctest

      * email

      * enum

      * faulthandler

      * functools

      * glob

      * gzip

      * heapq

      * http

      * http.client

      * idlelib 및 IDLE

      * imaplib

      * imghdr

      * importlib

      * inspect

      * io

      * ipaddress

      * json

      * linecache

      * locale

      * logging

      * lzma

      * math

      * multiprocessing

      * operator

      * os

      * pathlib

      * pickle

      * poplib

      * re

      * readline

      * selectors

      * Shutil

      * signal

      * smtpd

      * smtplib

      * sndhdr

      * socket

      * ssl

        * 메모리 BIO 지원

        * 응용 프로그램 계층 프로토콜 협상 지원

        * 기타 변경 사항

      * sqlite3

      * subprocess

      * sys

      * sysconfig

      * tarfile

      * threading

      * time

      * timeit

      * tkinter

      * traceback

      * types

      * unicodedata

      * unittest

      * unittest.mock

      * urllib

      * wsgiref

      * xmlrpc

      * xml.sax

      * zipfile

    * 기타 모듈 수준 변경

    * 최적화

    * 빌드와 C API 변경

    * 폐지

      * 새 키워드

      * 폐지된 파이썬 동작

      * 지원되지 않는 운영 체제

      * 폐지된 파이썬 모듈, 함수 및 메서드

    * 제거

      * API 및 기능 제거

    * 파이썬 3.5로 이식하기

      * 파이썬 동작의 변경

      * 파이썬 API의 변경

      * C API의 변경

    * 파이썬 3.5.4의 주목할만한 변경 사항

      * 새로운 "make regen-all" 빌드 대상

      * "make touch" 빌드 대상 제거

  * What's New In Python 3.4

    * Summary -- Release Highlights

    * New Features

      * PEP 453: Explicit Bootstrapping of PIP in Python Installations

        * Bootstrapping pip By Default

        * Documentation Changes

      * PEP 446: Newly Created File Descriptors Are Non-Inheritable

      * Improvements to Codec Handling

      * PEP 451: A ModuleSpec Type for the Import System

      * Other Language Changes

    * New Modules

      * asyncio

      * ensurepip

      * enum

      * pathlib

      * selectors

      * statistics

      * tracemalloc

    * Improved Modules

      * abc

      * aifc

      * argparse

      * audioop

      * base64

      * collections

      * colorsys

      * contextlib

      * dbm

      * dis

      * doctest

      * email

      * filecmp

      * functools

      * gc

      * glob

      * hashlib

      * hmac

      * html

      * http

      * idlelib and IDLE

      * importlib

      * inspect

      * ipaddress

      * logging

      * marshal

      * mmap

      * multiprocessing

      * operator

      * os

      * pdb

      * pickle

      * plistlib

      * poplib

      * pprint

      * pty

      * pydoc

      * re

      * resource

      * select

      * shelve

      * shutil

      * smtpd

      * smtplib

      * socket

      * sqlite3

      * ssl

      * stat

      * struct

      * subprocess

      * sunau

      * sys

      * tarfile

      * textwrap

      * threading

      * traceback

      * types

      * urllib

      * unittest

      * venv

      * wave

      * weakref

      * xml.etree

      * zipfile

    * CPython Implementation Changes

      * PEP 445: Customization of CPython Memory Allocators

      * PEP 442: Safe Object Finalization

      * PEP 456: Secure and Interchangeable Hash Algorithm

      * PEP 436: Argument Clinic

      * Other Build and C API Changes

      * Other Improvements

      * Significant Optimizations

    * Deprecated

      * Deprecations in the Python API

      * Deprecated Features

    * Removed

      * Operating Systems No Longer Supported

      * API and Feature Removals

      * Code Cleanups

    * Porting to Python 3.4

      * Changes in 'python' Command Behavior

      * Changes in the Python API

      * Changes in the C API

    * Changed in 3.4.3

      * PEP 476: Enabling certificate verification by default for
        stdlib http clients

  * What's New In Python 3.3

    * Summary -- Release highlights

    * PEP 405: Virtual Environments

    * PEP 420: Implicit Namespace Packages

    * PEP 3118: New memoryview implementation and buffer protocol
      documentation

      * Features

      * API changes

    * PEP 393: Flexible String Representation

      * Functionality

      * Performance and resource usage

    * PEP 397: Python Launcher for Windows

    * PEP 3151: Reworking the OS and IO exception hierarchy

    * PEP 380: Syntax for Delegating to a Subgenerator

    * PEP 409: Suppressing exception context

    * PEP 414: Explicit Unicode literals

    * PEP 3155: Qualified name for classes and functions

    * PEP 412: Key-Sharing Dictionary

    * PEP 362: Function Signature Object

    * PEP 421: Adding sys.implementation

      * SimpleNamespace

    * Using importlib as the Implementation of Import

      * New APIs

      * Visible Changes

    * Other Language Changes

    * A Finer-Grained Import Lock

    * Builtin functions and types

    * New Modules

      * faulthandler

      * ipaddress

      * lzma

    * Improved Modules

      * abc

      * array

      * base64

      * binascii

      * bz2

      * codecs

      * collections

      * contextlib

      * crypt

      * curses

      * datetime

      * decimal

        * Features

        * API changes

      * email

        * Policy Framework

        * Provisional Policy with New Header API

        * Other API Changes

      * ftplib

      * functools

      * gc

      * hmac

      * http

      * html

      * imaplib

      * inspect

      * io

      * itertools

      * logging

      * math

      * mmap

      * multiprocessing

      * nntplib

      * os

      * pdb

      * pickle

      * pydoc

      * re

      * sched

      * select

      * shlex

      * shutil

      * signal

      * smtpd

      * smtplib

      * socket

      * socketserver

      * sqlite3

      * ssl

      * stat

      * struct

      * subprocess

      * sys

      * tarfile

      * tempfile

      * textwrap

      * threading

      * time

      * types

      * unittest

      * urllib

      * webbrowser

      * xml.etree.ElementTree

      * zlib

    * Optimizations

    * Build and C API Changes

    * Deprecated

      * Unsupported Operating Systems

      * Deprecated Python modules, functions and methods

      * Deprecated functions and types of the C API

      * Deprecated features

    * Porting to Python 3.3

      * Porting Python code

      * Porting C code

      * Building C extensions

      * Command Line Switch Changes

  * What's New In Python 3.2

    * PEP 384: Defining a Stable ABI

    * PEP 389: Argparse Command Line Parsing Module

    * PEP 391:  Dictionary Based Configuration for Logging

    * PEP 3148:  The "concurrent.futures" module

    * PEP 3147:  PYC Repository Directories

    * PEP 3149: ABI Version Tagged .so Files

    * PEP 3333: Python Web Server Gateway Interface v1.0.1

    * Other Language Changes

    * New, Improved, and Deprecated Modules

      * email

      * elementtree

      * functools

      * itertools

      * collections

      * threading

      * datetime and time

      * math

      * abc

      * io

      * reprlib

      * logging

      * csv

      * contextlib

      * decimal and fractions

      * ftp

      * popen

      * select

      * gzip and zipfile

      * tarfile

      * hashlib

      * ast

      * os

      * shutil

      * sqlite3

      * html

      * socket

      * ssl

      * nntp

      * certificates

      * imaplib

      * http.client

      * unittest

      * random

      * poplib

      * asyncore

      * tempfile

      * inspect

      * pydoc

      * dis

      * dbm

      * ctypes

      * site

      * sysconfig

      * pdb

      * configparser

      * urllib.parse

      * mailbox

      * turtledemo

    * Multi-threading

    * Optimizations

    * Unicode

    * Codecs

    * Documentation

    * IDLE

    * Code Repository

    * Build and C API Changes

    * Porting to Python 3.2

  * What's New In Python 3.1

    * PEP 372: Ordered Dictionaries

    * PEP 378: Format Specifier for Thousands Separator

    * Other Language Changes

    * New, Improved, and Deprecated Modules

    * Optimizations

    * IDLE

    * Build and C API Changes

    * Porting to Python 3.1

  * What's New In Python 3.0

    * Common Stumbling Blocks

      * Print Is A Function

      * Views And Iterators Instead Of Lists

      * Ordering Comparisons

      * Integers

      * Text Vs. Data Instead Of Unicode Vs. 8-bit

    * Overview Of Syntax Changes

      * New Syntax

      * Changed Syntax

      * Removed Syntax

    * Changes Already Present In Python 2.6

    * Library Changes

    * **PEP 3101**: A New Approach To String Formatting

    * Changes To Exceptions

    * Miscellaneous Other Changes

      * Operators And Special Methods

      * Builtins

    * Build and C API Changes

    * Performance

    * Porting To Python 3.0

  * What's New in Python 2.7

    * The Future for Python 2.x

    * Changes to the Handling of Deprecation Warnings

    * Python 3.1 Features

    * PEP 372: Adding an Ordered Dictionary to collections

    * PEP 378: Format Specifier for Thousands Separator

    * PEP 389: The argparse Module for Parsing Command Lines

    * PEP 391: Dictionary-Based Configuration For Logging

    * PEP 3106: Dictionary Views

    * PEP 3137: The memoryview Object

    * Other Language Changes

      * Interpreter Changes

      * Optimizations

    * New and Improved Modules

      * New module: importlib

      * New module: sysconfig

      * ttk: Themed Widgets for Tk

      * Updated module: unittest

      * Updated module: ElementTree 1.3

    * Build and C API Changes

      * Capsules

      * Port-Specific Changes: Windows

      * Port-Specific Changes: Mac OS X

      * Port-Specific Changes: FreeBSD

    * Other Changes and Fixes

    * Porting to Python 2.7

    * New Features Added to Python 2.7 Maintenance Releases

      * Two new environment variables for debug mode

      * PEP 434: IDLE Enhancement Exception for All Branches

      * PEP 466: Network Security Enhancements for Python 2.7

      * PEP 477: Backport ensurepip (PEP 453) to Python 2.7

        * Bootstrapping pip By Default

        * Documentation Changes

      * PEP 476: Enabling certificate verification by default for
        stdlib http clients

      * PEP 493: HTTPS verification migration tools for Python 2.7

      * New "make regen-all" build target

      * Removal of "make touch" build target

    * Acknowledgements

  * What's New in Python 2.6

    * Python 3.0

    * Changes to the Development Process

      * New Issue Tracker: Roundup

      * New Documentation Format: reStructuredText Using Sphinx

    * PEP 343: The 'with' statement

      * Writing Context Managers

      * The contextlib module

    * PEP 366: Explicit Relative Imports From a Main Module

    * PEP 370: Per-user "site-packages" Directory

    * PEP 371: The "multiprocessing" Package

    * PEP 3101: Advanced String Formatting

    * PEP 3105: "print" As a Function

    * PEP 3110: Exception-Handling Changes

    * PEP 3112: Byte Literals

    * PEP 3116: New I/O Library

    * PEP 3118: Revised Buffer Protocol

    * PEP 3119: Abstract Base Classes

    * PEP 3127: Integer Literal Support and Syntax

    * PEP 3129: Class Decorators

    * PEP 3141: A Type Hierarchy for Numbers

      * The "fractions" Module

    * Other Language Changes

      * Optimizations

      * Interpreter Changes

    * New and Improved Modules

      * The "ast" module

      * The "future_builtins" module

      * The "json" module: JavaScript Object Notation

      * The "plistlib" module: A Property-List Parser

      * ctypes Enhancements

      * Improved SSL Support

    * Deprecations and Removals

    * Build and C API Changes

      * Port-Specific Changes: Windows

      * Port-Specific Changes: Mac OS X

      * Port-Specific Changes: IRIX

    * Porting to Python 2.6

    * Acknowledgements

  * What's New in Python 2.5

    * PEP 308: Conditional Expressions

    * PEP 309: Partial Function Application

    * PEP 314: Metadata for Python Software Packages v1.1

    * PEP 328: Absolute and Relative Imports

    * PEP 338: Executing Modules as Scripts

    * PEP 341: Unified try/except/finally

    * PEP 342: New Generator Features

    * PEP 343: The 'with' statement

      * Writing Context Managers

      * The contextlib module

    * PEP 352: Exceptions as New-Style Classes

    * PEP 353: Using ssize_t as the index type

    * PEP 357: The '__index__' method

    * Other Language Changes

      * Interactive Interpreter Changes

      * Optimizations

    * New, Improved, and Removed Modules

      * The ctypes package

      * The ElementTree package

      * The hashlib package

      * The sqlite3 package

      * The wsgiref package

    * Build and C API Changes

      * Port-Specific Changes

    * Porting to Python 2.5

    * Acknowledgements

  * What's New in Python 2.4

    * PEP 218: Built-In Set Objects

    * PEP 237: Unifying Long Integers and Integers

    * PEP 289: Generator Expressions

    * PEP 292: Simpler String Substitutions

    * PEP 318: Decorators for Functions and Methods

    * PEP 322: Reverse Iteration

    * PEP 324: New subprocess Module

    * PEP 327: Decimal Data Type

      * Why is Decimal needed?

      * The "Decimal" type

      * The "Context" type

    * PEP 328: Multi-line Imports

    * PEP 331: Locale-Independent Float/String Conversions

    * Other Language Changes

      * Optimizations

    * New, Improved, and Deprecated Modules

      * cookielib

      * doctest

    * Build and C API Changes

      * Port-Specific Changes

    * Porting to Python 2.4

    * Acknowledgements

  * What's New in Python 2.3

    * PEP 218: A Standard Set Datatype

    * PEP 255: Simple Generators

    * PEP 263: Source Code Encodings

    * PEP 273: Importing Modules from ZIP Archives

    * PEP 277: Unicode file name support for Windows NT

    * PEP 278: Universal Newline Support

    * PEP 279: enumerate()

    * PEP 282: The logging Package

    * PEP 285: A Boolean Type

    * PEP 293: Codec Error Handling Callbacks

    * PEP 301: Package Index and Metadata for Distutils

    * PEP 302: New Import Hooks

    * PEP 305: Comma-separated Files

    * PEP 307: Pickle Enhancements

    * Extended Slices

    * Other Language Changes

      * String Changes

      * Optimizations

    * New, Improved, and Deprecated Modules

      * Date/Time Type

      * The optparse Module

    * Pymalloc: A Specialized Object Allocator

    * Build and C API Changes

      * Port-Specific Changes

    * Other Changes and Fixes

    * Porting to Python 2.3

    * Acknowledgements

  * What's New in Python 2.2

    * Introduction

    * PEPs 252 and 253: Type and Class Changes

      * Old and New Classes

      * Descriptors

      * Multiple Inheritance: The Diamond Rule

      * Attribute Access

      * Related Links

    * PEP 234: Iterators

    * PEP 255: Simple Generators

    * PEP 237: Unifying Long Integers and Integers

    * PEP 238: Changing the Division Operator

    * Unicode Changes

    * PEP 227: Nested Scopes

    * New and Improved Modules

    * Interpreter Changes and Fixes

    * Other Changes and Fixes

    * Acknowledgements

  * What's New in Python 2.1

    * Introduction

    * PEP 227: Nested Scopes

    * PEP 236: __future__ Directives

    * PEP 207: Rich Comparisons

    * PEP 230: Warning Framework

    * PEP 229: New Build System

    * PEP 205: Weak References

    * PEP 232: Function Attributes

    * PEP 235: Importing Modules on Case-Insensitive Platforms

    * PEP 217: Interactive Display Hook

    * PEP 208: New Coercion Model

    * PEP 241: Metadata in Python Packages

    * New and Improved Modules

    * Other Changes and Fixes

    * Acknowledgements

  * What's New in Python 2.0

    * Introduction

    * What About Python 1.6?

    * New Development Process

    * Unicode

    * List Comprehensions

    * Augmented Assignment

    * String Methods

    * Garbage Collection of Cycles

    * Other Core Changes

      * Minor Language Changes

      * Changes to Built-in Functions

    * Porting to 2.0

    * Extending/Embedding Changes

    * Distutils: Making Modules Easy to Install

    * XML Modules

      * SAX2 Support

      * DOM Support

      * Relationship to PyXML

    * Module changes

    * New modules

    * IDLE Improvements

    * Deleted and Deprecated Modules

    * Acknowledgements

  * Changelog

    * Python next

      * Tests

      * Security

      * Library

      * Core and Builtins

      * C API

    * Python 3.12.8 final

      * macOS

      * Windows

      * Tools/Demos

      * Tests

      * Security

      * Library

      * IDLE

      * Documentation

      * Core and Builtins

      * C API

      * Build

    * Python 3.12.7 final

      * Windows

      * Tests

      * Security

      * Library

      * IDLE

      * Core and Builtins

      * C API

      * Build

    * Python 3.12.6 final

      * macOS

      * Windows

      * Tools/Demos

      * Tests

      * Security

      * Library

      * IDLE

      * Core and Builtins

      * Build

    * Python 3.12.5 final

      * Windows

      * Tests

      * Security

      * Library

      * IDLE

      * Documentation

      * Core and Builtins

      * Build

    * Python 3.12.4 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.12.3 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.12.2 final

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

    * Python 3.12.1 final

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.12.0 final

      * Core and Builtins

      * Library

      * Documentation

      * Windows

      * macOS

      * Tools/Demos

    * Python 3.12.0 release candidate 3

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

    * Python 3.12.0 release candidate 2

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.12.0 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.12.0 beta 4

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Tools/Demos

      * C API

    * Python 3.12.0 beta 3

      * Core and Builtins

      * Library

      * Tests

      * Windows

      * C API

    * Python 3.12.0 beta 2

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.12.0 beta 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.12.0 alpha 7

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

      * C API

    * Python 3.12.0 alpha 6

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * C API

    * Python 3.12.0 alpha 5

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

    * Python 3.12.0 alpha 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.12.0 alpha 3

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.12.0 alpha 2

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * C API

    * Python 3.12.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.11.0 beta 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.11.0 alpha 7

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.11.0 alpha 6

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * C API

    * Python 3.11.0 alpha 5

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.11.0 alpha 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * C API

    * Python 3.11.0 alpha 3

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * C API

    * Python 3.11.0 alpha 2

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.11.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.10.0 beta 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.10.0 alpha 7

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * C API

    * Python 3.10.0 alpha 6

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.10.0 alpha 5

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.10.0 alpha 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * macOS

      * Tools/Demos

      * C API

    * Python 3.10.0 alpha 3

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.10.0 alpha 2

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.10.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.9.0 beta 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.9.0 alpha 6

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.9.0 alpha 5

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.9.0 alpha 4

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * C API

    * Python 3.9.0 alpha 3

      * Core and Builtins

      * Library

      * Documentation

      * Build

      * IDLE

      * C API

    * Python 3.9.0 alpha 2

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.9.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.8.0 beta 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.8.0 alpha 4

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.8.0 alpha 3

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.8.0 alpha 2

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Windows

      * IDLE

    * Python 3.8.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.7.0 final

      * Library

      * C API

    * Python 3.7.0 release candidate 1

      * Core and Builtins

      * Library

      * Documentation

      * Build

      * Windows

      * IDLE

    * Python 3.7.0 beta 5

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * macOS

      * IDLE

    * Python 3.7.0 beta 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

    * Python 3.7.0 beta 3

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.7.0 beta 2

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

    * Python 3.7.0 beta 1

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * C API

    * Python 3.7.0 alpha 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Windows

      * Tools/Demos

      * C API

    * Python 3.7.0 alpha 3

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.7.0 alpha 2

      * Core and Builtins

      * Library

      * Documentation

      * Build

      * IDLE

      * C API

    * Python 3.7.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.6.6 final

    * Python 3.6.6 release candidate 1

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.6.5 final

      * Tests

      * Build

    * Python 3.6.5 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.6.4 final

    * Python 3.6.4 release candidate 1

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.6.3 final

      * Library

      * Build

    * Python 3.6.3 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * Tools/Demos

    * Python 3.6.2 final

    * Python 3.6.2 release candidate 2

      * Security

    * Python 3.6.2 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * C API

      * Build

      * Documentation

      * Tools/Demos

      * Tests

      * Windows

    * Python 3.6.1 final

      * Core and Builtins

      * Build

    * Python 3.6.1 release candidate 1

      * Core and Builtins

      * Library

      * IDLE

      * Windows

      * C API

      * Documentation

      * Tests

      * Build

    * Python 3.6.0 final

    * Python 3.6.0 release candidate 2

      * Core and Builtins

      * Tools/Demos

      * Windows

      * Build

    * Python 3.6.0 release candidate 1

      * Core and Builtins

      * Library

      * C API

      * Documentation

      * Tools/Demos

    * Python 3.6.0 beta 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

    * Python 3.6.0 beta 3

      * Core and Builtins

      * Library

      * Windows

      * Build

      * Tests

    * Python 3.6.0 beta 2

      * Core and Builtins

      * Library

      * Windows

      * C API

      * Build

      * Tests

    * Python 3.6.0 beta 1

      * Core and Builtins

      * Library

      * IDLE

      * C API

      * Tests

      * Build

      * Tools/Demos

      * Windows

    * Python 3.6.0 alpha 4

      * Core and Builtins

      * Library

      * IDLE

      * Tests

      * Windows

      * Build

    * Python 3.6.0 alpha 3

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * C API

      * Build

      * Tools/Demos

      * Documentation

      * Tests

    * Python 3.6.0 alpha 2

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

      * Windows

      * Build

      * C API

      * Tools/Demos

    * Python 3.6.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

      * C API

    * Python 3.5.5 final

    * Python 3.5.5 release candidate 1

      * Security

      * Core and Builtins

      * Library

    * Python 3.5.4 final

      * Library

    * Python 3.5.4 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * C API

    * Python 3.5.3 final

    * Python 3.5.3 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * C API

      * Documentation

      * Tests

      * Tools/Demos

      * Windows

      * Build

    * Python 3.5.2 final

      * Core and Builtins

      * Tests

      * IDLE

    * Python 3.5.2 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

    * Python 3.5.1 final

      * Core and Builtins

      * Windows

    * Python 3.5.1 release candidate 1

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

    * Python 3.5.0 final

      * Build

    * Python 3.5.0 release candidate 4

      * Library

      * Build

    * Python 3.5.0 release candidate 3

      * Core and Builtins

      * Library

    * Python 3.5.0 release candidate 2

      * Core and Builtins

      * Library

    * Python 3.5.0 release candidate 1

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

    * Python 3.5.0 beta 4

      * Core and Builtins

      * Library

      * Build

    * Python 3.5.0 beta 3

      * Core and Builtins

      * Library

      * Tests

      * Documentation

      * Build

    * Python 3.5.0 beta 2

      * Core and Builtins

      * Library

    * Python 3.5.0 beta 1

      * Core and Builtins

      * Library

      * IDLE

      * Tests

      * Documentation

      * Tools/Demos

    * Python 3.5.0 alpha 4

      * Core and Builtins

      * Library

      * Build

      * Tests

      * Tools/Demos

      * C API

    * Python 3.5.0 alpha 3

      * Core and Builtins

      * Library

      * Build

      * Tests

      * Tools/Demos

    * Python 3.5.0 alpha 2

      * Core and Builtins

      * Library

      * Build

      * C API

      * Windows

    * Python 3.5.0 alpha 1

      * Core and Builtins

      * Library

      * IDLE

      * Build

      * C API

      * Documentation

      * Tests

      * Tools/Demos

      * Windows

* 파이썬 자습서

  * 1. 입맛 돋우기

  * 2. 파이썬 인터프리터 사용하기

    * 2.1. 인터프리터 실행하기

      * 2.1.1. 인자 전달

      * 2.1.2. 대화형 모드

    * 2.2. 인터프리터와 환경

      * 2.2.1. 소스 코드 인코딩

  * 3. 파이썬의 간략한 소개

    * 3.1. 파이썬을 계산기로 사용하기

      * 3.1.1. 숫자

      * 3.1.2. Text

      * 3.1.3. 리스트

    * 3.2. 프로그래밍으로의 첫걸음

  * 4. 기타 제어 흐름 도구

    * 4.1. "if" 문

    * 4.2. "for" 문

    * 4.3. "range()" 함수

    * 4.4. "break" and "continue" Statements

    * 4.5. "else" Clauses on Loops

    * 4.6. "pass" 문

    * 4.7. "match" Statements

    * 4.8. 함수 정의하기

    * 4.9. 함수 정의 더 보기

      * 4.9.1. 기본 인자 값

      * 4.9.2. 키워드 인자

      * 4.9.3. 특수 매개 변수

        * 4.9.3.1. 위치-키워드(Positional-or-Keyword) 인자

        * 4.9.3.2. 위치 전용 매개 변수

        * 4.9.3.3. 키워드 전용 인자

        * 4.9.3.4. 함수 예제

        * 4.9.3.5. 복습

      * 4.9.4. 임의의 인자 목록

      * 4.9.5. 인자 목록 언 패킹

      * 4.9.6. 람다 표현식

      * 4.9.7. 도큐멘테이션 문자열

      * 4.9.8. 함수 어노테이션

    * 4.10. 막간극: 코딩 스타일

  * 5. 자료 구조

    * 5.1. 리스트 더 보기

      * 5.1.1. 리스트를 스택으로 사용하기

      * 5.1.2. 리스트를 큐로 사용하기

      * 5.1.3. 리스트 컴프리헨션

      * 5.1.4. 중첩된 리스트 컴프리헨션

    * 5.2. "del" 문

    * 5.3. 튜플과 시퀀스

    * 5.4. 집합

    * 5.5. 딕셔너리

    * 5.6. 루프 테크닉

    * 5.7. 조건 더 보기

    * 5.8. 시퀀스와 다른 형들을 비교하기

  * 6. 모듈

    * 6.1. 모듈 더 보기

      * 6.1.1. 모듈을 스크립트로 실행하기

      * 6.1.2. 모듈 검색 경로

      * 6.1.3. "컴파일된" 파이썬 파일

    * 6.2. 표준 모듈들

    * 6.3. "dir()" 함수

    * 6.4. 패키지

      * 6.4.1. 패키지에서 * 임포트 하기

      * 6.4.2. 패키지 내부 간의 참조

      * 6.4.3. 여러 디렉터리에 있는 패키지

  * 7. 입력과 출력

    * 7.1. 장식적인 출력 포매팅

      * 7.1.1. 포맷 문자열 리터럴

      * 7.1.2. 문자열 format() 메서드

      * 7.1.3. 수동 문자열 포매팅

      * 7.1.4. 예전의 문자열 포매팅

    * 7.2. 파일을 읽고 쓰기

      * 7.2.1. 파일 객체의 매소드

      * 7.2.2. "json" 으로 구조적인 데이터를 저장하기

  * 8. 에러와 예외

    * 8.1. 문법 에러

    * 8.2. 예외

    * 8.3. 예외 처리하기

    * 8.4. 예외 일으키기

    * 8.5. 예외 연쇄

    * 8.6. 사용자 정의 예외

    * 8.7. 뒷정리 동작 정의하기

    * 8.8. 미리 정의된 뒷정리 동작들

    * 8.9. Raising and Handling Multiple Unrelated Exceptions

    * 8.10. Enriching Exceptions with Notes

  * 9. 클래스

    * 9.1. 이름과 객체에 관한 한마디

    * 9.2. 파이썬 스코프와 이름 공간

      * 9.2.1. 스코프와 이름 공간 예

    * 9.3. 클래스와의 첫 만남

      * 9.3.1. 클래스 정의 문법

      * 9.3.2. 클래스 객체

      * 9.3.3. 인스턴스 객체

      * 9.3.4. 메서드 객체

      * 9.3.5. 클래스와 인스턴스 변수

    * 9.4. 기타 주의사항들

    * 9.5. 상속

      * 9.5.1. 다중 상속

    * 9.6. 비공개 변수

    * 9.7. 잡동사니

    * 9.8. 이터레이터

    * 9.9. 제너레이터

    * 9.10. 제너레이터 표현식

  * 10. 표준 라이브러리 둘러보기

    * 10.1. 운영 체제 인터페이스

    * 10.2. 파일 와일드카드

    * 10.3. 명령행 인자

    * 10.4. 에러 출력 리디렉션과 프로그램 종료

    * 10.5. 문자열 패턴 매칭

    * 10.6. 수학

    * 10.7. 인터넷 액세스

    * 10.8. 날짜와 시간

    * 10.9. 데이터 압축

    * 10.10. 성능 측정

    * 10.11. 품질 관리

    * 10.12. 배터리가 포함됩니다

  * 11. 표준 라이브러리 둘러보기 --- 2부

    * 11.1. 출력 포매팅

    * 11.2. 템플릿

    * 11.3. 바이너리 데이터 레코드 배치 작업

    * 11.4. 다중 스레딩

    * 11.5. 로깅

    * 11.6. 약한 참조

    * 11.7. 리스트 작업 도구

    * 11.8. Decimal Floating-Point Arithmetic

  * 12. 가상 환경 및 패키지

    * 12.1. 소개

    * 12.2. 가상 환경 만들기

    * 12.3. pip로 패키지 관리하기

  * 13. 이제 뭘 하지?

  * 14. 대화형 입력 편집 및 히스토리 치환

    * 14.1. 탭 완성 및 히스토리 편집

    * 14.2. 대화형 인터프리터 대안

  * 15. Floating-Point Arithmetic:  Issues and Limitations

    * 15.1. 표현 오류

  * 16. 부록

    * 16.1. 대화형 모드

      * 16.1.1. 에러 처리

      * 16.1.2. 실행 가능한 파이썬 스크립트

      * 16.1.3. 대화형 시작 파일

      * 16.1.4. 커스터마이제이션 모듈

* 파이썬 설정 및 사용법

  * 1. 명령 줄과 환경

    * 1.1. 명령 줄

      * 1.1.1. 인터페이스 옵션

      * 1.1.2. 일반 옵션

      * 1.1.3. 기타 옵션

      * 1.1.4. 사용해서는 안 되는 옵션

    * 1.2. 환경 변수

      * 1.2.1. 디버그 모드 변수

  * 2. 유닉스 플랫폼에서 파이썬 사용하기

    * 2.1. 최신 버전의 파이썬 내려받기와 설치

      * 2.1.1. 리눅스

      * 2.1.2. FreeBSD와 OpenBSD

    * 2.2. 파이썬 빌드하기

    * 2.3. 파이썬 관련 경로와 파일

    * 2.4. 잡동사니

    * 2.5. Custom OpenSSL

  * 3. Configure Python

    * 3.1. Build Requirements

    * 3.2. Generated files

      * 3.2.1. configure script

    * 3.3. Configure Options

      * 3.3.1. General Options

      * 3.3.2. WebAssembly Options

      * 3.3.3. Install Options

      * 3.3.4. Performance options

      * 3.3.5. Python Debug Build

      * 3.3.6. Debug options

      * 3.3.7. Linker options

      * 3.3.8. Libraries options

      * 3.3.9. Security Options

      * 3.3.10. macOS Options

      * 3.3.11. Cross Compiling Options

    * 3.4. Python Build System

      * 3.4.1. Main files of the build system

      * 3.4.2. Main build steps

      * 3.4.3. Main Makefile targets

      * 3.4.4. C extensions

    * 3.5. Compiler and linker flags

      * 3.5.1. Preprocessor flags

      * 3.5.2. Compiler flags

      * 3.5.3. Linker flags

  * 4. 윈도우에서 파이썬 사용하기

    * 4.1. 전체 설치 프로그램

      * 4.1.1. 설치 단계

      * 4.1.2. MAX_PATH 제한 제거하기

      * 4.1.3. UI 없이 설치하기

      * 4.1.4. 다운로드 없이 설치하기

      * 4.1.5. 설치 수정하기

    * 4.2. Microsoft Store 패키지

      * 4.2.1. Known issues

        * 4.2.1.1. Redirection of local data, registry, and temporary
          paths

    * 4.3. nuget.org 패키지

    * 4.4. 내장 가능한 패키지

      * 4.4.1. 파이썬 응용 프로그램

      * 4.4.2. 파이썬 내장하기

    * 4.5. 대체 번들

    * 4.6. 파이썬 구성하기

      * 4.6.1. 보충 설명: 환경 변수 설정하기

      * 4.6.2. 파이썬 실행 파일 찾기

    * 4.7. UTF-8 모드

    * 4.8. 윈도우 용 파이썬 런처

      * 4.8.1. 시작하기

        * 4.8.1.1. 명령 줄에서

        * 4.8.1.2. 가상 환경

        * 4.8.1.3. 스크립트에서

        * 4.8.1.4. 파일 연결에서

      * 4.8.2. 셔뱅 줄

      * 4.8.3. 셔뱅 줄의 인자

      * 4.8.4. 사용자 정의

        * 4.8.4.1. INI 파일을 통한 사용자 정의

        * 4.8.4.2. 기본 파이썬 버전 사용자 정의

      * 4.8.5. 진단

      * 4.8.6. Dry Run

      * 4.8.7. Install on demand

      * 4.8.8. Return codes

    * 4.9. 모듈 찾기

    * 4.10. 추가 모듈

      * 4.10.1. PyWin32

      * 4.10.2. cx_Freeze

    * 4.11. 윈도우에서 파이썬 컴파일하기

    * 4.12. 기타 플랫폼

  * 5. Using Python on a Mac

    * 5.1. Getting and Installing Python

      * 5.1.1. 파이썬 스크립트를 실행하는 방법

      * 5.1.2. GUI로 스크립트 실행하기

      * 5.1.3. 구성

    * 5.2. IDE

    * 5.3. 추가 파이썬 패키지 설치하기

    * 5.4. GUI Programming

    * 5.5. Distributing Python Applications

    * 5.6. 기타 자원

  * 6. 편집기와 IDE

* 파이썬 언어 레퍼런스

  * 1. 개요

    * 1.1. 대안 구현들

    * 1.2. 표기법

  * 2. 어휘 분석

    * 2.1. 줄 구조(Line structure)

      * 2.1.1. 논리적인 줄

      * 2.1.2. 물리적인 줄

      * 2.1.3. 주석

      * 2.1.4. 인코딩 선언

      * 2.1.5. 명시적인 줄 결합

      * 2.1.6. 묵시적인 줄 결합

      * 2.1.7. 빈 줄

      * 2.1.8. 들여쓰기

      * 2.1.9. 토큰 사이의 공백

    * 2.2. 다른 토큰들

    * 2.3. 식별자와 키워드

      * 2.3.1. 키워드

      * 2.3.2. Soft Keywords

      * 2.3.3. 식별자의 예약 영역

    * 2.4. 리터럴

      * 2.4.1. 문자열과 바이트열 리터럴

        * 2.4.1.1. Escape sequences

      * 2.4.2. 문자열 리터럴 이어붙이기

      * 2.4.3. f-strings

      * 2.4.4. 숫자 리터럴

      * 2.4.5. 정수 리터럴

      * 2.4.6. Floating-point literals

      * 2.4.7. 허수 리터럴

    * 2.5. 연산자

    * 2.6. 구분자

  * 3. 데이터 모델

    * 3.1. 객체, 값, 형

    * 3.2. 표준형 계층

      * 3.2.1. None

      * 3.2.2. NotImplemented

      * 3.2.3. Ellipsis

      * 3.2.4. "numbers.Number"

        * 3.2.4.1. "numbers.Integral"

        * 3.2.4.2. "numbers.Real" ("float")

        * 3.2.4.3. "numbers.Complex" ("complex")

      * 3.2.5. 시퀀스들

        * 3.2.5.1. 불변 시퀀스

        * 3.2.5.2. 가변 시퀀스

      * 3.2.6. 집합 형들(Set types)

      * 3.2.7. 매핑(Mappings)

        * 3.2.7.1. 딕셔너리(Dictionaries)

      * 3.2.8. 콜러블(Callable types)

        * 3.2.8.1. 사용자 정의 함수

          * 3.2.8.1.1. Special read-only attributes

            * "__globals__"

            * "__closure__"

          * 3.2.8.1.2. Special writable attributes

            * "__doc__"

            * "__name__"

            * "__qualname__"

            * "__module__"

            * "__defaults__"

            * "__code__"

            * "__dict__"

            * "__annotations__"

            * "__kwdefaults__"

            * "__type_params__"

        * 3.2.8.2. 인스턴스 메서드(Instance methods)

          * "__self__"

          * "__func__"

          * "__doc__"

          * "__name__"

          * "__module__"

        * 3.2.8.3. 제너레이터 함수(Generator functions)

        * 3.2.8.4. 코루틴 함수(Coroutine functions)

        * 3.2.8.5. 비동기 제너레이터 함수(Asynchronous generator
          functions)

        * 3.2.8.6. 내장 함수(Built-in functions)

        * 3.2.8.7. 내장 메서드(Built-in methods)

        * 3.2.8.8. 클래스(Classes)

        * 3.2.8.9. 클래스 인스턴스(Class Instances)

      * 3.2.9. 모듈(Modules)

        * 3.2.9.1. Import-related attributes on module objects

          * "__name__"

          * "__spec__"

          * "__package__"

          * "__loader__"

          * "__path__"

          * "__file__"

          * "__cached__"

        * 3.2.9.2. Other writable attributes on module objects

          * "__doc__"

          * "__annotations__"

        * 3.2.9.3. Module dictionaries

          * "__dict__"

      * 3.2.10. 사용자 정의 클래스(Custom classes)

        * 3.2.10.1. Special attributes

          * "__name__"

          * "__qualname__"

          * "__module__"

          * "__dict__"

          * "__bases__"

          * "__doc__"

          * "__annotations__"

          * "__type_params__"

          * "__mro__"

        * 3.2.10.2. Special methods

          * "mro()"

          * "__subclasses__()"

      * 3.2.11. 클래스 인스턴스(Class instances)

        * 3.2.11.1. Special attributes

          * "__class__"

          * "__dict__"

      * 3.2.12. I/O 객체 (파일 객체라고도 알려져 있습니다)

      * 3.2.13. 내부 형(Internal types)

        * 3.2.13.1. 코드 객체(Code objects)

          * 3.2.13.1.1. Special read-only attributes

            * "co_name"

            * "co_qualname"

            * "co_argcount"

            * "co_posonlyargcount"

            * "co_kwonlyargcount"

            * "co_nlocals"

            * "co_varnames"

            * "co_cellvars"

            * "co_freevars"

            * "co_code"

            * "co_consts"

            * "co_names"

            * "co_filename"

            * "co_firstlineno"

            * "co_lnotab"

            * "co_stacksize"

            * "co_flags"

          * 3.2.13.1.2. Methods on code objects

            * "co_positions()"

            * "co_lines()"

            * "replace()"

        * 3.2.13.2. 프레임 객체(Frame objects)

          * 3.2.13.2.1. Special read-only attributes

            * "f_back"

            * "f_code"

            * "f_locals"

            * "f_globals"

            * "f_builtins"

            * "f_lasti"

          * 3.2.13.2.2. Special writable attributes

            * "f_trace"

            * "f_trace_lines"

            * "f_trace_opcodes"

            * "f_lineno"

          * 3.2.13.2.3. Frame object methods

            * "clear()"

        * 3.2.13.3. 트레이스백 객체(Traceback objects)

          * "tb_frame"

          * "tb_lineno"

          * "tb_lasti"

          * "tb_next"

        * 3.2.13.4. 슬라이스 객체(Slice objects)

          * "indices()"

        * 3.2.13.5. 스태틱 메서드 객체(Static method objects)

        * 3.2.13.6. 클래스 메서드 객체(Class method objects)

    * 3.3. 특수 메서드 이름들

      * 3.3.1. 기본적인 커스터마이제이션

        * "__new__()"

        * "__init__()"

        * "__del__()"

        * "__repr__()"

        * "__str__()"

        * "__bytes__()"

        * "__format__()"

        * "__lt__()"

        * "__le__()"

        * "__eq__()"

        * "__ne__()"

        * "__gt__()"

        * "__ge__()"

        * "__hash__()"

        * "__bool__()"

      * 3.3.2. 어트리뷰트 액세스 커스터마이제이션

        * "__getattr__()"

        * "__getattribute__()"

        * "__setattr__()"

        * "__delattr__()"

        * "__dir__()"

        * 3.3.2.1. 모듈 어트리뷰트 액세스 커스터마이제이션

        * 3.3.2.2. 디스크립터 구현하기

          * "__get__()"

          * "__set__()"

          * "__delete__()"

          * "__objclass__"

        * 3.3.2.3. 디스크립터 호출하기

        * 3.3.2.4. __slots__

          * "__slots__"

      * 3.3.3. 클래스 생성 커스터마이제이션

        * "__init_subclass__()"

        * "__set_name__()"

        * 3.3.3.1. 메타 클래스

        * 3.3.3.2. MRO 항목 결정하기

          * "__mro_entries__()"

        * 3.3.3.3. 적절한 메타 클래스 선택하기

        * 3.3.3.4. 클래스 이름 공간 준비하기

        * 3.3.3.5. 클래스 바디 실행하기

        * 3.3.3.6. 클래스 객체 만들기

        * 3.3.3.7. 메타 클래스의 용도

      * 3.3.4. 인스턴스 및 서브 클래스 검사 커스터마이제이션

        * "__instancecheck__()"

        * "__subclasscheck__()"

      * 3.3.5. 제네릭 형 흉내 내기

        * "__class_getitem__()"

        * 3.3.5.1. The purpose of *__class_getitem__*

        * 3.3.5.2. *__class_getitem__* versus *__getitem__*

      * 3.3.6. 콜러블 객체 흉내 내기

        * "__call__()"

      * 3.3.7. 컨테이너형 흉내 내기

        * "__len__()"

        * "__length_hint__()"

        * "__getitem__()"

        * "__setitem__()"

        * "__delitem__()"

        * "__missing__()"

        * "__iter__()"

        * "__reversed__()"

        * "__contains__()"

      * 3.3.8. 숫자 형 흉내 내기

        * "__add__()"

        * "__sub__()"

        * "__mul__()"

        * "__matmul__()"

        * "__truediv__()"

        * "__floordiv__()"

        * "__mod__()"

        * "__divmod__()"

        * "__pow__()"

        * "__lshift__()"

        * "__rshift__()"

        * "__and__()"

        * "__xor__()"

        * "__or__()"

        * "__radd__()"

        * "__rsub__()"

        * "__rmul__()"

        * "__rmatmul__()"

        * "__rtruediv__()"

        * "__rfloordiv__()"

        * "__rmod__()"

        * "__rdivmod__()"

        * "__rpow__()"

        * "__rlshift__()"

        * "__rrshift__()"

        * "__rand__()"

        * "__rxor__()"

        * "__ror__()"

        * "__iadd__()"

        * "__isub__()"

        * "__imul__()"

        * "__imatmul__()"

        * "__itruediv__()"

        * "__ifloordiv__()"

        * "__imod__()"

        * "__ipow__()"

        * "__ilshift__()"

        * "__irshift__()"

        * "__iand__()"

        * "__ixor__()"

        * "__ior__()"

        * "__neg__()"

        * "__pos__()"

        * "__abs__()"

        * "__invert__()"

        * "__complex__()"

        * "__int__()"

        * "__float__()"

        * "__index__()"

        * "__round__()"

        * "__trunc__()"

        * "__floor__()"

        * "__ceil__()"

      * 3.3.9. with 문 컨텍스트 관리자

        * "__enter__()"

        * "__exit__()"

      * 3.3.10. Customizing positional arguments in class pattern
        matching

        * "__match_args__"

      * 3.3.11. Emulating buffer types

        * "__buffer__()"

        * "__release_buffer__()"

      * 3.3.12. 특수 메서드 조회

    * 3.4. 코루틴(Coroutines)

      * 3.4.1. 어웨이터블 객체(Awaitable Objects)

        * "__await__()"

      * 3.4.2. 코루틴 객체(Coroutine Objects)

        * "send()"

        * "throw()"

        * "close()"

      * 3.4.3. 비동기 이터레이터(Asynchronous Iterators)

        * "__aiter__()"

        * "__anext__()"

      * 3.4.4. 비동기 컨텍스트 관리자

        * "__aenter__()"

        * "__aexit__()"

  * 4. 실행 모델

    * 4.1. 프로그램의 구조

    * 4.2. 이름과 연결(binding)

      * 4.2.1. 이름의 연결

      * 4.2.2. 이름의 검색(resolution)

      * 4.2.3. Annotation scopes

      * 4.2.4. Lazy evaluation

      * 4.2.5. builtins 와 제한된 실행

      * 4.2.6. 동적 기능과의 상호작용

    * 4.3. 예외

  * 5. 임포트 시스템

    * 5.1. "importlib"

    * 5.2. 패키지(package)

      * 5.2.1. 정규 패키지

      * 5.2.2. 이름 공간 패키지

    * 5.3. 검색

      * 5.3.1. 모듈 캐시

      * 5.3.2. 파인더(finder)와 로더(loader)

      * 5.3.3. 임포트 훅(import hooks)

      * 5.3.4. 메타 경로(meta path)

    * 5.4. 로딩(loading)

      * 5.4.1. 로더

      * 5.4.2. 서브 모듈

      * 5.4.3. Module specs

      * 5.4.4. __path__ attributes on modules

      * 5.4.5. 모듈 repr

      * 5.4.6. 캐시된 바이트 코드 무효화

    * 5.5. 경로 기반 파인더

      * 5.5.1. 경로 엔트리 파인더

      * 5.5.2. 경로 엔트리 파인더 프로토콜

    * 5.6. 표준 임포트 시스템 교체하기

    * 5.7. 패키지 상대 임포트

    * 5.8. __main__ 에 대한 특별한 고려

      * 5.8.1. __main__.__spec__

    * 5.9. 참고문헌

  * 6. 표현식

    * 6.1. 산술 변환

    * 6.2. 아톰 (Atoms)

      * 6.2.1. 식별자 (이름)

        * 6.2.1.1. Private name mangling

      * 6.2.2. 리터럴 (Literals)

      * 6.2.3. 괄호 안에 넣은 형

      * 6.2.4. 리스트, 집합, 딕셔너리의 디스플레이(display)

      * 6.2.5. 리스트 디스플레이

      * 6.2.6. 집합 디스플레이

      * 6.2.7. 딕셔너리 디스플레이

      * 6.2.8. 제너레이터 표현식 (Generator expressions)

      * 6.2.9. 일드 표현식(Yield expressions)

        * 6.2.9.1. 제너레이터-이터레이터 메서드

          * "__next__()"

          * "send()"

          * "throw()"

          * "close()"

        * 6.2.9.2. 사용 예

        * 6.2.9.3. 비동기 제너레이터 함수

        * 6.2.9.4. 비동기 제너레이터-이터레이터 메서드

          * "__anext__()"

          * "asend()"

          * "athrow()"

          * "aclose()"

    * 6.3. 프라이머리

      * 6.3.1. 어트리뷰트 참조

      * 6.3.2. 서브스크립션(Subscriptions)

      * 6.3.3. 슬라이싱(Slicings)

      * 6.3.4. 호출

    * 6.4. 어웨이트 표현식

    * 6.5. 거듭제곱 연산자

    * 6.6. 일 항 산술과 비트 연산

    * 6.7. 이항 산술 연산

    * 6.8. 시프트 연산

    * 6.9. 이항 비트 연산

    * 6.10. 비교

      * 6.10.1. 값 비교

      * 6.10.2. 멤버십 검사 연산

      * 6.10.3. 아이덴티티 비교

    * 6.11. 논리 연산(Boolean operations)

    * 6.12. 대입 표현식

    * 6.13. 조건 표현식(Conditional expressions)

    * 6.14. 람다(Lambdas)

    * 6.15. 표현식 목록(Expression lists)

    * 6.16. 값을 구하는 순서

    * 6.17. 연산자 우선순위

  * 7. 단순문(Simple statements)

    * 7.1. 표현식 문

    * 7.2. 대입문

      * 7.2.1. 증분 대입문(Augmented assignment statements)

      * 7.2.2. 어노테이트된 대입문(Annotated assignment statements)

    * 7.3. "assert" 문

    * 7.4. "pass" 문

    * 7.5. "del" 문

    * 7.6. "return" 문

    * 7.7. "yield" 문

    * 7.8. "raise" 문

    * 7.9. "break" 문

    * 7.10. "continue" 문

    * 7.11. 임포트("import") 문

      * 7.11.1. 퓨처 문

    * 7.12. "global" 문

    * 7.13. "nonlocal" 문

    * 7.14. The "type" statement

  * 8. 복합문(Compound statements)

    * 8.1. "if" 문

    * 8.2. "while" 문

    * 8.3. "for" 문

    * 8.4. "try" 문

      * 8.4.1. "except" clause

      * 8.4.2. "except*" clause

      * 8.4.3. "else" clause

      * 8.4.4. "finally" clause

    * 8.5. "with" 문

    * 8.6. The "match" statement

      * 8.6.1. Overview

      * 8.6.2. Guards

      * 8.6.3. Irrefutable Case Blocks

      * 8.6.4. Patterns

        * 8.6.4.1. OR Patterns

        * 8.6.4.2. AS Patterns

        * 8.6.4.3. Literal Patterns

        * 8.6.4.4. Capture Patterns

        * 8.6.4.5. Wildcard Patterns

        * 8.6.4.6. Value Patterns

        * 8.6.4.7. Group Patterns

        * 8.6.4.8. Sequence Patterns

        * 8.6.4.9. Mapping Patterns

        * 8.6.4.10. Class Patterns

    * 8.7. 함수 정의

    * 8.8. 클래스 정의

    * 8.9. 코루틴

      * 8.9.1. 코루틴 함수 정의

      * 8.9.2. "async for" 문

      * 8.9.3. "async with" 문

    * 8.10. Type parameter lists

      * 8.10.1. Generic functions

      * 8.10.2. Generic classes

      * 8.10.3. Generic type aliases

  * 9. 최상위 요소들

    * 9.1. 완전한 파이썬 프로그램

    * 9.2. 파일 입력

    * 9.3. 대화형 입력

    * 9.4. 표현식 입력

  * 10. 전체 문법 규격

* 파이썬 표준 라이브러리

  * 소개

    * 가용성에 대한 참고 사항

      * WebAssembly platforms

  * 내장 함수

    * "abs()"

    * "aiter()"

    * "all()"

    * "anext()"

    * "any()"

    * "ascii()"

    * "bin()"

    * "bool"

    * "breakpoint()"

    * "callable()"

    * "chr()"

    * "classmethod()"

    * "compile()"

    * "complex"

    * "delattr()"

    * "dir()"

    * "divmod()"

    * "enumerate()"

    * "eval()"

    * "exec()"

    * "filter()"

    * "float"

    * "format()"

    * "getattr()"

    * "globals()"

    * "hasattr()"

    * "hash()"

    * "help()"

    * "hex()"

    * "id()"

    * "input()"

    * "int"

    * "isinstance()"

    * "issubclass()"

    * "iter()"

    * "len()"

    * "locals()"

    * "map()"

    * "max()"

    * "min()"

    * "next()"

    * "object"

    * "oct()"

    * "open()"

    * "ord()"

    * "pow()"

    * "print()"

    * "property"

      * "getter()"

      * "setter()"

      * "deleter()"

    * "repr()"

    * "reversed()"

    * "round()"

    * "setattr()"

    * "slice"

      * "start"

      * "stop"

      * "step"

    * "sorted()"

    * "staticmethod()"

    * "sum()"

    * "super"

    * "type"

    * "vars()"

    * "zip()"

    * "__import__()"

  * 내장 상수

    * "False"

    * "True"

    * "None"

    * "NotImplemented"

    * "Ellipsis"

    * "__debug__"

    * "site" 모듈에 의해 추가된 상수들

      * "quit"

      * "exit"

      * "copyright"

      * "credits"

      * "license"

  * 내장형

    * 논리값 검사

    * 논리 연산 --- "and", "or", "not"

    * 비교

    * 숫자 형 --- "int", "float", "complex"

      * 정수 형에 대한 비트 연산

      * 정수 형에 대한 추가 메서드

        * "bit_length()"

        * "bit_count()"

        * "to_bytes()"

        * "from_bytes()"

        * "as_integer_ratio()"

        * "is_integer()"

      * 실수에 대한 추가 메서드

        * "as_integer_ratio()"

        * "is_integer()"

        * "hex()"

        * "fromhex()"

      * 숫자 형의 해싱

    * Boolean Type - "bool"

    * 이터레이터 형

      * "__iter__()"

      * "__iter__()"

      * "__next__()"

      * 제너레이터 형

    * 시퀀스 형 --- "list", "tuple", "range"

      * 공통 시퀀스 연산

      * 불변 시퀀스 형

      * 가변 시퀀스 형

      * 리스트

        * "list"

          * "sort()"

      * 튜플

        * "tuple"

      * 범위

        * "range"

          * "start"

          * "stop"

          * "step"

    * 텍스트 시퀀스 형 --- "str"

      * "str"

      * 문자열 메서드

        * "capitalize()"

        * "casefold()"

        * "center()"

        * "count()"

        * "encode()"

        * "endswith()"

        * "expandtabs()"

        * "find()"

        * "format()"

        * "format_map()"

        * "index()"

        * "isalnum()"

        * "isalpha()"

        * "isascii()"

        * "isdecimal()"

        * "isdigit()"

        * "isidentifier()"

        * "islower()"

        * "isnumeric()"

        * "isprintable()"

        * "isspace()"

        * "istitle()"

        * "isupper()"

        * "join()"

        * "ljust()"

        * "lower()"

        * "lstrip()"

        * "maketrans()"

        * "partition()"

        * "removeprefix()"

        * "removesuffix()"

        * "replace()"

        * "rfind()"

        * "rindex()"

        * "rjust()"

        * "rpartition()"

        * "rsplit()"

        * "rstrip()"

        * "split()"

        * "splitlines()"

        * "startswith()"

        * "strip()"

        * "swapcase()"

        * "title()"

        * "translate()"

        * "upper()"

        * "zfill()"

      * "printf" 스타일 문자열 포매팅

    * 바이너리 시퀀스 형 --- "bytes", "bytearray", "memoryview"

      * 바이트열 객체

        * "bytes"

          * "fromhex()"

          * "hex()"

      * 바이트 배열 객체

        * "bytearray"

          * "fromhex()"

          * "hex()"

      * 바이트열 과 바이트 배열 연산

        * "count()"

        * "count()"

        * "removeprefix()"

        * "removeprefix()"

        * "removesuffix()"

        * "removesuffix()"

        * "decode()"

        * "decode()"

        * "endswith()"

        * "endswith()"

        * "find()"

        * "find()"

        * "index()"

        * "index()"

        * "join()"

        * "join()"

        * "maketrans()"

        * "maketrans()"

        * "partition()"

        * "partition()"

        * "replace()"

        * "replace()"

        * "rfind()"

        * "rfind()"

        * "rindex()"

        * "rindex()"

        * "rpartition()"

        * "rpartition()"

        * "startswith()"

        * "startswith()"

        * "translate()"

        * "translate()"

        * "center()"

        * "center()"

        * "ljust()"

        * "ljust()"

        * "lstrip()"

        * "lstrip()"

        * "rjust()"

        * "rjust()"

        * "rsplit()"

        * "rsplit()"

        * "rstrip()"

        * "rstrip()"

        * "split()"

        * "split()"

        * "strip()"

        * "strip()"

        * "capitalize()"

        * "capitalize()"

        * "expandtabs()"

        * "expandtabs()"

        * "isalnum()"

        * "isalnum()"

        * "isalpha()"

        * "isalpha()"

        * "isascii()"

        * "isascii()"

        * "isdigit()"

        * "isdigit()"

        * "islower()"

        * "islower()"

        * "isspace()"

        * "isspace()"

        * "istitle()"

        * "istitle()"

        * "isupper()"

        * "isupper()"

        * "lower()"

        * "lower()"

        * "splitlines()"

        * "splitlines()"

        * "swapcase()"

        * "swapcase()"

        * "title()"

        * "title()"

        * "upper()"

        * "upper()"

        * "zfill()"

        * "zfill()"

      * "printf" 스타일 바이너리 포매팅

      * 메모리 뷰

        * "memoryview"

          * "__eq__()"

          * "tobytes()"

          * "hex()"

          * "tolist()"

          * "toreadonly()"

          * "release()"

          * "cast()"

          * "obj"

          * "nbytes"

          * "readonly"

          * "format"

          * "itemsize"

          * "ndim"

          * "shape"

          * "strides"

          * "suboffsets"

          * "c_contiguous"

          * "f_contiguous"

          * "contiguous"

    * 집합 형 --- "set", "frozenset"

      * "set"

      * "frozenset"

        * "isdisjoint()"

        * "issubset()"

        * "issuperset()"

        * "union()"

        * "intersection()"

        * "difference()"

        * "symmetric_difference()"

        * "copy()"

        * "update()"

        * "intersection_update()"

        * "difference_update()"

        * "symmetric_difference_update()"

        * "add()"

        * "remove()"

        * "discard()"

        * "pop()"

        * "clear()"

    * 매핑 형 --- "dict"

      * "dict"

        * "clear()"

        * "copy()"

        * "fromkeys()"

        * "get()"

        * "items()"

        * "keys()"

        * "pop()"

        * "popitem()"

        * "setdefault()"

        * "update()"

        * "values()"

      * 딕셔너리 뷰 객체

    * 컨텍스트 관리자 형

      * "__enter__()"

      * "__exit__()"

    * Type Annotation Types --- *Generic Alias*, *Union*

      * 제네릭 에일리어스 형

        * Standard Generic Classes

        * Special Attributes of "GenericAlias" objects

          * "__origin__"

          * "__args__"

          * "__parameters__"

          * "__unpacked__"

      * Union Type

    * 기타 내장형

      * 모듈

      * 클래스와 클래스 인스턴스

      * 함수

      * 메서드

      * 코드 객체

      * 형 객체

      * 널 객체

      * Ellipsis 객체

      * NotImplemented 객체

      * 내부 객체

    * 특수 어트리뷰트

      * "__name__"

      * "__qualname__"

      * "__module__"

      * "__doc__"

      * "__type_params__"

    * Integer string conversion length limitation

      * Affected APIs

      * Configuring the limit

      * Recommended configuration

  * 내장 예외

    * Exception context

      * "__context__"

      * "__cause__"

      * "__suppress_context__"

    * Inheriting from built-in exceptions

    * 베이스 클래스

      * "BaseException"

        * "args"

        * "with_traceback()"

        * "__traceback__"

        * "add_note()"

        * "__notes__"

      * "Exception"

      * "ArithmeticError"

      * "BufferError"

      * "LookupError"

    * 구체적인 예외

      * "AssertionError"

      * "AttributeError"

      * "EOFError"

      * "FloatingPointError"

      * "GeneratorExit"

      * "ImportError"

        * "name"

        * "path"

      * "ModuleNotFoundError"

      * "IndexError"

      * "KeyError"

      * "KeyboardInterrupt"

      * "MemoryError"

      * "NameError"

      * "NotImplementedError"

      * "OSError"

        * "errno"

        * "winerror"

        * "strerror"

        * "filename"

        * "filename2"

      * "OverflowError"

      * "RecursionError"

      * "ReferenceError"

      * "RuntimeError"

      * "StopIteration"

        * "value"

      * "StopAsyncIteration"

      * "SyntaxError"

        * "filename"

        * "lineno"

        * "offset"

        * "text"

        * "end_lineno"

        * "end_offset"

      * "IndentationError"

      * "TabError"

      * "SystemError"

      * "SystemExit"

        * "code"

      * "TypeError"

      * "UnboundLocalError"

      * "UnicodeError"

        * "encoding"

        * "reason"

        * "object"

        * "start"

        * "end"

      * "UnicodeEncodeError"

      * "UnicodeDecodeError"

      * "UnicodeTranslateError"

      * "ValueError"

      * "ZeroDivisionError"

      * "EnvironmentError"

      * "IOError"

      * "WindowsError"

      * OS 예외

        * "BlockingIOError"

          * "characters_written"

        * "ChildProcessError"

        * "ConnectionError"

        * "BrokenPipeError"

        * "ConnectionAbortedError"

        * "ConnectionRefusedError"

        * "ConnectionResetError"

        * "FileExistsError"

        * "FileNotFoundError"

        * "InterruptedError"

        * "IsADirectoryError"

        * "NotADirectoryError"

        * "PermissionError"

        * "ProcessLookupError"

        * "TimeoutError"

    * 경고

      * "Warning"

      * "UserWarning"

      * "DeprecationWarning"

      * "PendingDeprecationWarning"

      * "SyntaxWarning"

      * "RuntimeWarning"

      * "FutureWarning"

      * "ImportWarning"

      * "UnicodeWarning"

      * "EncodingWarning"

      * "BytesWarning"

      * "ResourceWarning"

    * Exception groups

      * "ExceptionGroup"

      * "BaseExceptionGroup"

        * "message"

        * "exceptions"

        * "subgroup()"

        * "split()"

        * "derive()"

    * 예외 계층 구조

  * 텍스트 처리 서비스

    * "string" --- Common string operations

      * 문자열 상수

        * "ascii_letters"

        * "ascii_lowercase"

        * "ascii_uppercase"

        * "digits"

        * "hexdigits"

        * "octdigits"

        * "punctuation"

        * "printable"

        * "whitespace"

      * 사용자 지정 문자열 포매팅

        * "Formatter"

          * "format()"

          * "vformat()"

          * "parse()"

          * "get_field()"

          * "get_value()"

          * "check_unused_args()"

          * "format_field()"

          * "convert_field()"

      * 포맷 문자열 문법

        * 포맷 명세 미니 언어

        * 포맷 예제

      * 템플릿 문자열

        * "Template"

          * "substitute()"

          * "safe_substitute()"

          * "is_valid()"

          * "get_identifiers()"

          * "template"

      * 도움 함수

        * "capwords()"

    * "re" --- Regular expression operations

      * 정규식 문법

      * 모듈 내용

        * Flags

          * "RegexFlag"

          * "A"

          * "ASCII"

          * "DEBUG"

          * "I"

          * "IGNORECASE"

          * "L"

          * "LOCALE"

          * "M"

          * "MULTILINE"

          * "NOFLAG"

          * "S"

          * "DOTALL"

          * "U"

          * "UNICODE"

          * "X"

          * "VERBOSE"

        * Functions

          * "compile()"

          * "search()"

          * "match()"

          * "fullmatch()"

          * "split()"

          * "findall()"

          * "finditer()"

          * "sub()"

          * "subn()"

          * "escape()"

          * "purge()"

        * Exceptions

          * "error"

            * "msg"

            * "pattern"

            * "pos"

            * "lineno"

            * "colno"

      * 정규식 객체

        * "Pattern"

        * "search()"

        * "match()"

        * "fullmatch()"

        * "split()"

        * "findall()"

        * "finditer()"

        * "sub()"

        * "subn()"

        * "flags"

        * "groups"

        * "groupindex"

        * "pattern"

      * 일치 객체

        * "Match"

        * "expand()"

        * "group()"

        * "__getitem__()"

        * "groups()"

        * "groupdict()"

        * "start()"

        * "end()"

        * "span()"

        * "pos"

        * "endpos"

        * "lastindex"

        * "lastgroup"

        * "re"

        * "string"

      * 정규식 예제

        * 쌍 검사하기

        * scanf() 시뮬레이션

        * search() 대 match()

        * 전화번호부 만들기

        * 텍스트 뒤섞기

        * 모든 부사 찾기

        * 모든 부사와 그 위치 찾기

        * 날 문자열 표기법

        * 토크나이저 작성하기

    * "difflib" --- Helpers for computing deltas

      * "Differ"

      * "HtmlDiff"

        * "__init__()"

        * "make_file()"

        * "make_table()"

      * "context_diff()"

      * "get_close_matches()"

      * "ndiff()"

      * "restore()"

      * "unified_diff()"

      * "diff_bytes()"

      * "IS_LINE_JUNK()"

      * "IS_CHARACTER_JUNK()"

      * SequenceMatcher 객체

        * "SequenceMatcher"

          * "set_seqs()"

          * "set_seq1()"

          * "set_seq2()"

          * "find_longest_match()"

          * "get_matching_blocks()"

          * "get_opcodes()"

          * "get_grouped_opcodes()"

          * "ratio()"

          * "quick_ratio()"

          * "real_quick_ratio()"

      * SequenceMatcher 예제

      * Differ 객체

        * "compare()"

      * Differ 예제

      * difflib의 명령 줄 인터페이스

      * ndiff example

    * "textwrap" --- Text wrapping and filling

      * "wrap()"

      * "fill()"

      * "shorten()"

      * "dedent()"

      * "indent()"

      * "TextWrapper"

        * "width"

        * "expand_tabs"

        * "tabsize"

        * "replace_whitespace"

        * "drop_whitespace"

        * "initial_indent"

        * "subsequent_indent"

        * "fix_sentence_endings"

        * "break_long_words"

        * "break_on_hyphens"

        * "max_lines"

        * "placeholder"

        * "wrap()"

        * "fill()"

    * "unicodedata" --- Unicode Database

      * "lookup()"

      * "name()"

      * "decimal()"

      * "digit()"

      * "numeric()"

      * "category()"

      * "bidirectional()"

      * "combining()"

      * "east_asian_width()"

      * "mirrored()"

      * "decomposition()"

      * "normalize()"

      * "is_normalized()"

      * "unidata_version"

      * "ucd_3_2_0"

    * "stringprep" --- Internet String Preparation

      * "in_table_a1()"

      * "in_table_b1()"

      * "map_table_b2()"

      * "map_table_b3()"

      * "in_table_c11()"

      * "in_table_c12()"

      * "in_table_c11_c12()"

      * "in_table_c21()"

      * "in_table_c22()"

      * "in_table_c21_c22()"

      * "in_table_c3()"

      * "in_table_c4()"

      * "in_table_c5()"

      * "in_table_c6()"

      * "in_table_c7()"

      * "in_table_c8()"

      * "in_table_c9()"

      * "in_table_d1()"

      * "in_table_d2()"

    * "readline" --- GNU readline interface

      * 초기화 파일

        * "parse_and_bind()"

        * "read_init_file()"

      * 줄 버퍼

        * "get_line_buffer()"

        * "insert_text()"

        * "redisplay()"

      * 히스토리 파일

        * "read_history_file()"

        * "write_history_file()"

        * "append_history_file()"

        * "get_history_length()"

        * "set_history_length()"

      * 히스토리 목록

        * "clear_history()"

        * "get_current_history_length()"

        * "get_history_item()"

        * "remove_history_item()"

        * "replace_history_item()"

        * "add_history()"

        * "set_auto_history()"

      * 시동 훅

        * "set_startup_hook()"

        * "set_pre_input_hook()"

      * 완성

        * "set_completer()"

        * "get_completer()"

        * "get_completion_type()"

        * "get_begidx()"

        * "get_endidx()"

        * "set_completer_delims()"

        * "get_completer_delims()"

        * "set_completion_display_matches_hook()"

      * 예제

    * "rlcompleter" --- Completion function for GNU readline

      * "Completer"

        * "complete()"

  * 바이너리 데이터 서비스

    * "struct" --- Interpret bytes as packed binary data

      * 함수와 예외

        * "error"

        * "pack()"

        * "pack_into()"

        * "unpack()"

        * "unpack_from()"

        * "iter_unpack()"

        * "calcsize()"

      * 포맷 문자열

        * 바이트 순서, 크기 및 정렬

        * 포맷 문자

        * 예

      * Applications

        * Native Formats

        * Standard Formats

      * 클래스

        * "Struct"

          * "pack()"

          * "pack_into()"

          * "unpack()"

          * "unpack_from()"

          * "iter_unpack()"

          * "format"

          * "size"

    * "codecs" --- Codec registry and base classes

      * "encode()"

      * "decode()"

      * "lookup()"

      * "CodecInfo"

        * "name"

        * "encode"

        * "decode"

        * "incrementalencoder"

        * "incrementaldecoder"

        * "streamwriter"

        * "streamreader"

      * "getencoder()"

      * "getdecoder()"

      * "getincrementalencoder()"

      * "getincrementaldecoder()"

      * "getreader()"

      * "getwriter()"

      * "register()"

      * "unregister()"

      * "open()"

      * "EncodedFile()"

      * "iterencode()"

      * "iterdecode()"

      * "BOM"

      * "BOM_BE"

      * "BOM_LE"

      * "BOM_UTF8"

      * "BOM_UTF16"

      * "BOM_UTF16_BE"

      * "BOM_UTF16_LE"

      * "BOM_UTF32"

      * "BOM_UTF32_BE"

      * "BOM_UTF32_LE"

      * 코덱 베이스 클래스

        * 에러 처리기

          * "register_error()"

          * "lookup_error()"

          * "strict_errors()"

          * "ignore_errors()"

          * "replace_errors()"

          * "backslashreplace_errors()"

          * "xmlcharrefreplace_errors()"

          * "namereplace_errors()"

        * 상태 없는 인코딩과 디코딩

          * "Codec"

            * "encode()"

            * "decode()"

        * 증분 인코딩과 디코딩

          * IncrementalEncoder 객체

            * "IncrementalEncoder"

              * "encode()"

              * "reset()"

              * "getstate()"

              * "setstate()"

          * IncrementalDecoder 객체

            * "IncrementalDecoder"

              * "decode()"

              * "reset()"

              * "getstate()"

              * "setstate()"

        * 스트림 인코딩과 디코딩

          * StreamWriter 객체

            * "StreamWriter"

              * "write()"

              * "writelines()"

              * "reset()"

          * StreamReader 객체

            * "StreamReader"

              * "read()"

              * "readline()"

              * "readlines()"

              * "reset()"

          * StreamReaderWriter 객체

            * "StreamReaderWriter"

          * StreamRecoder 객체

            * "StreamRecoder"

      * 인코딩과 유니코드

      * 표준 인코딩

      * 파이썬 특정 인코딩

        * 텍스트 인코딩

        * 바이너리 변환

        * 텍스트 변환

      * "encodings.idna" --- 응용 프로그램에서의 국제화된 도메인 이름

        * "nameprep()"

        * "ToASCII()"

        * "ToUnicode()"

      * "encodings.mbcs" --- 윈도우 ANSI 코드 페이지

      * "encodings.utf_8_sig" --- BOM 서명이 있는 UTF-8 코덱

  * 데이터형

    * "datetime" --- Basic date and time types

      * 어웨어와 나이브 객체

      * 상수

        * "MINYEAR"

        * "MAXYEAR"

        * "UTC"

      * 사용 가능한 형

        * 공통 속성

        * 객체가 어웨어한지 나이브한지 판단하기

      * "timedelta" 객체

        * "timedelta"

        * "min"

        * "max"

        * "resolution"

        * "days"

        * "seconds"

        * "microseconds"

        * "total_seconds()"

        * 사용 예: "timedelta"

      * "date" 객체

        * "date"

        * "today()"

        * "fromtimestamp()"

        * "fromordinal()"

        * "fromisoformat()"

        * "fromisocalendar()"

        * "min"

        * "max"

        * "resolution"

        * "year"

        * "month"

        * "day"

        * "replace()"

        * "timetuple()"

        * "toordinal()"

        * "weekday()"

        * "isoweekday()"

        * "isocalendar()"

        * "isoformat()"

        * "__str__()"

        * "ctime()"

        * "strftime()"

        * "__format__()"

        * 사용 예: "date"

      * "datetime" 객체

        * "datetime"

        * "today()"

        * "now()"

        * "utcnow()"

        * "fromtimestamp()"

        * "utcfromtimestamp()"

        * "fromordinal()"

        * "combine()"

        * "fromisoformat()"

        * "fromisocalendar()"

        * "strptime()"

        * "min"

        * "max"

        * "resolution"

        * "year"

        * "month"

        * "day"

        * "hour"

        * "minute"

        * "second"

        * "microsecond"

        * "tzinfo"

        * "fold"

        * "date()"

        * "time()"

        * "timetz()"

        * "replace()"

        * "astimezone()"

        * "utcoffset()"

        * "dst()"

        * "tzname()"

        * "timetuple()"

        * "utctimetuple()"

        * "toordinal()"

        * "timestamp()"

        * "weekday()"

        * "isoweekday()"

        * "isocalendar()"

        * "isoformat()"

        * "__str__()"

        * "ctime()"

        * "strftime()"

        * "__format__()"

        * 사용 예: "datetime"

      * "time" 객체

        * "time"

        * "min"

        * "max"

        * "resolution"

        * "hour"

        * "minute"

        * "second"

        * "microsecond"

        * "tzinfo"

        * "fold"

        * "fromisoformat()"

        * "replace()"

        * "isoformat()"

        * "__str__()"

        * "strftime()"

        * "__format__()"

        * "utcoffset()"

        * "dst()"

        * "tzname()"

        * 사용 예: "time"

      * "tzinfo" 객체

        * "tzinfo"

        * "utcoffset()"

        * "dst()"

        * "tzname()"

        * "fromutc()"

      * "timezone" 객체

        * "timezone"

        * "utcoffset()"

        * "tzname()"

        * "dst()"

        * "fromutc()"

        * "utc"

      * "strftime()" and "strptime()" Behavior

        * "strftime()" and "strptime()" Format Codes

        * 기술적 세부 사항

    * "zoneinfo" --- IANA time zone support

      * "ZoneInfo" 사용하기

      * 데이터 소스

        * 데이터 소스 구성

          * 컴파일 시간 구성

          * 환경 구성

          * 실행 시간 구성

      * "ZoneInfo" 클래스

        * "ZoneInfo"

        * "from_file()"

        * "no_cache()"

        * "clear_cache()"

        * "key"

        * 문자열 표현

        * 피클 직렬화

      * 함수

        * "available_timezones()"

        * "reset_tzpath()"

      * 전역

        * "TZPATH"

      * 예외와 경고

        * "ZoneInfoNotFoundError"

        * "InvalidTZPathWarning"

    * "calendar" --- General calendar-related functions

      * "Calendar"

        * "iterweekdays()"

        * "itermonthdates()"

        * "itermonthdays()"

        * "itermonthdays2()"

        * "itermonthdays3()"

        * "itermonthdays4()"

        * "monthdatescalendar()"

        * "monthdays2calendar()"

        * "monthdayscalendar()"

        * "yeardatescalendar()"

        * "yeardays2calendar()"

        * "yeardayscalendar()"

      * "TextCalendar"

        * "formatmonth()"

        * "prmonth()"

        * "formatyear()"

        * "pryear()"

      * "HTMLCalendar"

        * "formatmonth()"

        * "formatyear()"

        * "formatyearpage()"

        * "formatmonthname()"

        * "cssclasses"

        * "cssclass_noday"

        * "cssclasses_weekday_head"

        * "cssclass_month_head"

        * "cssclass_month"

        * "cssclass_year"

        * "cssclass_year_head"

      * "LocaleTextCalendar"

      * "LocaleHTMLCalendar"

      * "setfirstweekday()"

      * "firstweekday()"

      * "isleap()"

      * "leapdays()"

      * "weekday()"

      * "weekheader()"

      * "monthrange()"

      * "monthcalendar()"

      * "prmonth()"

      * "month()"

      * "prcal()"

      * "calendar()"

      * "timegm()"

      * "day_name"

      * "day_abbr"

      * "MONDAY"

      * "TUESDAY"

      * "WEDNESDAY"

      * "THURSDAY"

      * "FRIDAY"

      * "SATURDAY"

      * "SUNDAY"

      * "Day"

      * "month_name"

      * "month_abbr"

      * "JANUARY"

      * "FEBRUARY"

      * "MARCH"

      * "APRIL"

      * "MAY"

      * "JUNE"

      * "JULY"

      * "AUGUST"

      * "SEPTEMBER"

      * "OCTOBER"

      * "NOVEMBER"

      * "DECEMBER"

      * "Month"

      * "IllegalMonthError"

        * "month"

      * "IllegalWeekdayError"

        * "weekday"

      * Command-Line Usage

    * "collections" --- Container datatypes

      * "ChainMap" 객체

        * "ChainMap"

          * "maps"

          * "new_child()"

          * "parents"

        * "ChainMap" 예제와 조리법

      * "Counter" 객체

        * "Counter"

          * "elements()"

          * "most_common()"

          * "subtract()"

          * "total()"

          * "fromkeys()"

          * "update()"

      * "deque" 객체

        * "deque"

          * "append()"

          * "appendleft()"

          * "clear()"

          * "copy()"

          * "count()"

          * "extend()"

          * "extendleft()"

          * "index()"

          * "insert()"

          * "pop()"

          * "popleft()"

          * "remove()"

          * "reverse()"

          * "rotate()"

          * "maxlen"

        * "deque" 조리법

      * "defaultdict" 객체

        * "defaultdict"

          * "__missing__()"

          * "default_factory"

        * "defaultdict" 예

      * 이름있는 필드를 가진 튜플을 위한 "namedtuple()" 팩토리 함수

        * "namedtuple()"

        * "_make()"

        * "_asdict()"

        * "_replace()"

        * "_fields"

        * "_field_defaults"

      * "OrderedDict" 객체

        * "OrderedDict"

          * "popitem()"

          * "move_to_end()"

        * "OrderedDict" 예제와 조리법

      * "UserDict" 객체

        * "UserDict"

          * "data"

      * "UserList" 객체

        * "UserList"

          * "data"

      * "UserString" 객체

        * "UserString"

          * "data"

    * "collections.abc" --- Abstract Base Classes for Containers

      * Collections 추상 베이스 클래스

      * Collections Abstract Base Classes -- Detailed Descriptions

        * "Container"

        * "Hashable"

        * "Sized"

        * "Callable"

        * "Iterable"

        * "Collection"

        * "Iterator"

        * "Reversible"

        * "Generator"

        * "Sequence"

        * "MutableSequence"

        * "ByteString"

        * "Set"

        * "MutableSet"

        * "Mapping"

        * "MutableMapping"

        * "MappingView"

        * "ItemsView"

        * "KeysView"

        * "ValuesView"

        * "Awaitable"

        * "Coroutine"

        * "AsyncIterable"

        * "AsyncIterator"

        * "AsyncGenerator"

        * "Buffer"

      * Examples and Recipes

    * "heapq" --- Heap queue algorithm

      * "heappush()"

      * "heappop()"

      * "heappushpop()"

      * "heapify()"

      * "heapreplace()"

      * "merge()"

      * "nlargest()"

      * "nsmallest()"

      * 기본 예

      * 우선순위 큐 구현 참고 사항

      * 이론

    * "bisect" --- Array bisection algorithm

      * "bisect_left()"

      * "bisect_right()"

      * "bisect()"

      * "insort_left()"

      * "insort_right()"

      * "insort()"

      * Performance Notes

      * 정렬된 리스트 검색하기

      * Examples

    * "array" --- Efficient arrays of numeric values

      * "typecodes"

      * "array"

        * "typecode"

        * "itemsize"

        * "append()"

        * "buffer_info()"

        * "byteswap()"

        * "count()"

        * "extend()"

        * "frombytes()"

        * "fromfile()"

        * "fromlist()"

        * "fromunicode()"

        * "index()"

        * "insert()"

        * "pop()"

        * "remove()"

        * "reverse()"

        * "tobytes()"

        * "tofile()"

        * "tolist()"

        * "tounicode()"

    * "weakref" --- 약한 참조

      * "ref"

        * "__callback__"

      * "proxy()"

      * "getweakrefcount()"

      * "getweakrefs()"

      * "WeakKeyDictionary"

      * "keyrefs()"

      * "WeakValueDictionary"

      * "valuerefs()"

      * "WeakSet"

      * "WeakMethod"

      * "finalize"

        * "__call__()"

        * "detach()"

        * "peek()"

        * "alive"

        * "atexit"

      * "ReferenceType"

      * "ProxyType"

      * "CallableProxyType"

      * "ProxyTypes"

      * 약한 참조 객체

      * 예

      * 파이널라이저 객체

      * Comparing finalizers with "__del__()" methods

    * "types" --- Dynamic type creation and names for built-in types

      * 동적 형 생성

        * "new_class()"

        * "prepare_class()"

        * "resolve_bases()"

        * "get_original_bases()"

      * 표준 인터프리터 형

        * "NoneType"

        * "FunctionType"

        * "LambdaType"

        * "GeneratorType"

        * "CoroutineType"

        * "AsyncGeneratorType"

        * "CodeType"

        * "CellType"

        * "MethodType"

        * "BuiltinFunctionType"

        * "BuiltinMethodType"

        * "WrapperDescriptorType"

        * "MethodWrapperType"

        * "NotImplementedType"

        * "MethodDescriptorType"

        * "ClassMethodDescriptorType"

        * "ModuleType"

        * "EllipsisType"

        * "GenericAlias"

        * "UnionType"

        * "TracebackType"

        * "FrameType"

        * "GetSetDescriptorType"

        * "MemberDescriptorType"

        * "MappingProxyType"

          * "copy()"

          * "get()"

          * "items()"

          * "keys()"

          * "values()"

      * 추가 유틸리티 클래스와 함수

        * "SimpleNamespace"

        * "DynamicClassAttribute()"

      * 코루틴 유틸리티 함수

        * "coroutine()"

    * "copy" --- Shallow and deep copy operations

      * "copy()"

      * "deepcopy()"

      * "Error"

    * "pprint" --- Data pretty printer

      * Functions

        * "pp()"

        * "pprint()"

        * "pformat()"

        * "isreadable()"

        * "isrecursive()"

        * "saferepr()"

      * PrettyPrinter 객체

        * "PrettyPrinter"

        * "pformat()"

        * "pprint()"

        * "isreadable()"

        * "isrecursive()"

        * "format()"

      * 예제

    * "reprlib" --- Alternate "repr()" implementation

      * "Repr"

      * "aRepr"

      * "repr()"

      * "recursive_repr()"

      * Repr 객체

        * "fillvalue"

        * "maxlevel"

        * "maxdict"

        * "maxlist"

        * "maxtuple"

        * "maxset"

        * "maxfrozenset"

        * "maxdeque"

        * "maxarray"

        * "maxlong"

        * "maxstring"

        * "maxother"

        * "indent"

        * "repr()"

        * "repr1()"

      * Repr 객체 서브 클래싱

    * "enum" --- Support for enumerations

      * 모듈 내용

      * Data Types

        * "EnumType"

          * "__call__()"

          * "__contains__()"

          * "__dir__()"

          * "__getitem__()"

          * "__iter__()"

          * "__len__()"

          * "__members__"

          * "__reversed__()"

        * "Enum"

          * "name"

          * "value"

          * "_name_"

          * "_value_"

          * "_order_"

          * "_ignore_"

          * "__dir__()"

          * "_generate_next_value_()"

          * "__init__()"

          * "__init_subclass__()"

          * "_missing_()"

          * "__new__()"

          * "__repr__()"

          * "__str__()"

          * "__format__()"

        * "IntEnum"

        * "StrEnum"

        * "Flag"

          * "__contains__()"

          * "__or__()"

          * "__and__()"

          * "__xor__()"

          * "_numeric_repr_()"

        * "IntFlag"

        * "ReprEnum"

        * "EnumCheck"

          * "UNIQUE"

          * "CONTINUOUS"

          * "NAMED_FLAGS"

        * "FlagBoundary"

          * "STRICT"

          * "CONFORM"

          * "EJECT"

          * "KEEP"

        * 지원되는 "__dunder__" 이름

        * 지원되는 "_sunder_" 이름

      * Utilities and Decorators

        * "auto"

        * "property()"

        * "unique()"

        * "verify()"

        * "member()"

        * "nonmember()"

        * "global_enum()"

        * "show_flag_values()"

      * Notes

    * "graphlib" --- Functionality to operate with graph-like
      structures

      * "TopologicalSorter"

        * "add()"

        * "prepare()"

        * "is_active()"

        * "done()"

        * "get_ready()"

        * "static_order()"

      * 예외

        * "CycleError"

  * 숫자와 수학 모듈

    * "numbers" --- Numeric abstract base classes

      * "Number"

      * 숫자 계층

        * "Complex"

          * "real"

          * "imag"

          * "conjugate()"

        * "Real"

        * "Rational"

          * "numerator"

          * "denominator"

        * "Integral"

      * Notes for type implementers

        * 더 많은 숫자 추상 베이스 클래스(ABC) 추가

        * 산술 연산 구현

    * "math" --- Mathematical functions

      * 수론 및 표현 함수

        * "ceil()"

        * "comb()"

        * "copysign()"

        * "fabs()"

        * "factorial()"

        * "floor()"

        * "fmod()"

        * "frexp()"

        * "fsum()"

        * "gcd()"

        * "isclose()"

        * "isfinite()"

        * "isinf()"

        * "isnan()"

        * "isqrt()"

        * "lcm()"

        * "ldexp()"

        * "modf()"

        * "nextafter()"

        * "perm()"

        * "prod()"

        * "remainder()"

        * "sumprod()"

        * "trunc()"

        * "ulp()"

      * 지수와 로그 함수

        * "cbrt()"

        * "exp()"

        * "exp2()"

        * "expm1()"

        * "log()"

        * "log1p()"

        * "log2()"

        * "log10()"

        * "pow()"

        * "sqrt()"

      * 삼각 함수

        * "acos()"

        * "asin()"

        * "atan()"

        * "atan2()"

        * "cos()"

        * "dist()"

        * "hypot()"

        * "sin()"

        * "tan()"

      * 각도 변환

        * "degrees()"

        * "radians()"

      * 쌍곡선 함수

        * "acosh()"

        * "asinh()"

        * "atanh()"

        * "cosh()"

        * "sinh()"

        * "tanh()"

      * 특수 함수

        * "erf()"

        * "erfc()"

        * "gamma()"

        * "lgamma()"

      * 상수

        * "pi"

        * "e"

        * "tau"

        * "inf"

        * "nan"

    * "cmath" --- Mathematical functions for complex numbers

      * 극좌표 변환

        * "phase()"

        * "polar()"

        * "rect()"

      * 거듭제곱과 로그 함수

        * "exp()"

        * "log()"

        * "log10()"

        * "sqrt()"

      * 삼각 함수

        * "acos()"

        * "asin()"

        * "atan()"

        * "cos()"

        * "sin()"

        * "tan()"

      * 쌍곡선(hyperbolic) 함수

        * "acosh()"

        * "asinh()"

        * "atanh()"

        * "cosh()"

        * "sinh()"

        * "tanh()"

      * 분류 함수

        * "isfinite()"

        * "isinf()"

        * "isnan()"

        * "isclose()"

      * 상수

        * "pi"

        * "e"

        * "tau"

        * "inf"

        * "infj"

        * "nan"

        * "nanj"

    * "decimal" --- Decimal fixed-point and floating-point arithmetic

      * 빠른 시작 자습서

      * Decimal 객체

        * "Decimal"

          * "adjusted()"

          * "as_integer_ratio()"

          * "as_tuple()"

          * "canonical()"

          * "compare()"

          * "compare_signal()"

          * "compare_total()"

          * "compare_total_mag()"

          * "conjugate()"

          * "copy_abs()"

          * "copy_negate()"

          * "copy_sign()"

          * "exp()"

          * "from_float()"

          * "fma()"

          * "is_canonical()"

          * "is_finite()"

          * "is_infinite()"

          * "is_nan()"

          * "is_normal()"

          * "is_qnan()"

          * "is_signed()"

          * "is_snan()"

          * "is_subnormal()"

          * "is_zero()"

          * "ln()"

          * "log10()"

          * "logb()"

          * "logical_and()"

          * "logical_invert()"

          * "logical_or()"

          * "logical_xor()"

          * "max()"

          * "max_mag()"

          * "min()"

          * "min_mag()"

          * "next_minus()"

          * "next_plus()"

          * "next_toward()"

          * "normalize()"

          * "number_class()"

          * "quantize()"

          * "radix()"

          * "remainder_near()"

          * "rotate()"

          * "same_quantum()"

          * "scaleb()"

          * "shift()"

          * "sqrt()"

          * "to_eng_string()"

          * "to_integral()"

          * "to_integral_exact()"

          * "to_integral_value()"

        * 논리적 피연산자

      * Context 객체

        * "getcontext()"

        * "setcontext()"

        * "localcontext()"

        * "BasicContext"

        * "ExtendedContext"

        * "DefaultContext"

        * "Context"

          * "clear_flags()"

          * "clear_traps()"

          * "copy()"

          * "copy_decimal()"

          * "create_decimal()"

          * "create_decimal_from_float()"

          * "Etiny()"

          * "Etop()"

          * "abs()"

          * "add()"

          * "canonical()"

          * "compare()"

          * "compare_signal()"

          * "compare_total()"

          * "compare_total_mag()"

          * "copy_abs()"

          * "copy_negate()"

          * "copy_sign()"

          * "divide()"

          * "divide_int()"

          * "divmod()"

          * "exp()"

          * "fma()"

          * "is_canonical()"

          * "is_finite()"

          * "is_infinite()"

          * "is_nan()"

          * "is_normal()"

          * "is_qnan()"

          * "is_signed()"

          * "is_snan()"

          * "is_subnormal()"

          * "is_zero()"

          * "ln()"

          * "log10()"

          * "logb()"

          * "logical_and()"

          * "logical_invert()"

          * "logical_or()"

          * "logical_xor()"

          * "max()"

          * "max_mag()"

          * "min()"

          * "min_mag()"

          * "minus()"

          * "multiply()"

          * "next_minus()"

          * "next_plus()"

          * "next_toward()"

          * "normalize()"

          * "number_class()"

          * "plus()"

          * "power()"

          * "quantize()"

          * "radix()"

          * "remainder()"

          * "remainder_near()"

          * "rotate()"

          * "same_quantum()"

          * "scaleb()"

          * "shift()"

          * "sqrt()"

          * "subtract()"

          * "to_eng_string()"

          * "to_integral_exact()"

          * "to_sci_string()"

      * 상수

        * "MAX_PREC"

        * "MAX_EMAX"

        * "MIN_EMIN"

        * "MIN_ETINY"

        * "HAVE_THREADS"

        * "HAVE_CONTEXTVAR"

      * 자리 올림 모드

        * "ROUND_CEILING"

        * "ROUND_DOWN"

        * "ROUND_FLOOR"

        * "ROUND_HALF_DOWN"

        * "ROUND_HALF_EVEN"

        * "ROUND_HALF_UP"

        * "ROUND_UP"

        * "ROUND_05UP"

      * 신호

        * "Clamped"

        * "DecimalException"

        * "DivisionByZero"

        * "Inexact"

        * "InvalidOperation"

        * "Overflow"

        * "Rounded"

        * "Subnormal"

        * "Underflow"

        * "FloatOperation"

      * Floating-Point Notes

        * 증가시킨 정밀도로 자리 올림 오차 줄이기

        * 특수 값

      * 스레드로 작업하기

      * 조리법

      * Decimal FAQ

    * "fractions" --- Rational numbers

      * "Fraction"

        * "numerator"

        * "denominator"

        * "as_integer_ratio()"

        * "is_integer()"

        * "from_float()"

        * "from_decimal()"

        * "limit_denominator()"

        * "__floor__()"

        * "__ceil__()"

        * "__round__()"

        * "__format__()"

    * "random" --- Generate pseudo-random numbers

      * 관리 함수

        * "seed()"

        * "getstate()"

        * "setstate()"

      * 바이트열 함수

        * "randbytes()"

      * 정수 함수

        * "randrange()"

        * "randint()"

        * "getrandbits()"

      * 시퀀스 함수

        * "choice()"

        * "choices()"

        * "shuffle()"

        * "sample()"

      * Discrete distributions

        * "binomialvariate()"

      * 실수 분포

        * "random()"

        * "uniform()"

        * "triangular()"

        * "betavariate()"

        * "expovariate()"

        * "gammavariate()"

        * "gauss()"

        * "lognormvariate()"

        * "normalvariate()"

        * "vonmisesvariate()"

        * "paretovariate()"

        * "weibullvariate()"

      * 대체 생성기

        * "Random"

          * "seed()"

          * "getstate()"

          * "setstate()"

          * "random()"

          * "getrandbits()"

        * "SystemRandom"

      * 재현성에 대한 참고 사항

      * 예제

      * 조리법

    * "statistics" --- Mathematical statistics functions

      * 평균과 중심 위치의 측정

      * 분산 측정

      * Statistics for relations between two inputs

      * 함수 세부 사항

        * "mean()"

        * "fmean()"

        * "geometric_mean()"

        * "harmonic_mean()"

        * "median()"

        * "median_low()"

        * "median_high()"

        * "median_grouped()"

        * "mode()"

        * "multimode()"

        * "pstdev()"

        * "pvariance()"

        * "stdev()"

        * "variance()"

        * "quantiles()"

        * "covariance()"

        * "correlation()"

        * "linear_regression()"

      * 예외

        * "StatisticsError"

      * "NormalDist" 객체

        * "NormalDist"

          * "mean"

          * "median"

          * "mode"

          * "stdev"

          * "variance"

          * "from_samples()"

          * "samples()"

          * "pdf()"

          * "cdf()"

          * "inv_cdf()"

          * "overlap()"

          * "quantiles()"

          * "zscore()"

      * Examples and Recipes

        * Classic probability problems

        * Monte Carlo inputs for simulations

        * Approximating binomial distributions

        * Naive bayesian classifier

        * Kernel density estimation

  * 함수형 프로그래밍 모듈

    * "itertools" --- Functions creating iterators for efficient
      looping

      * Itertool Functions

        * "accumulate()"

        * "batched()"

        * "chain()"

        * "from_iterable()"

        * "combinations()"

        * "combinations_with_replacement()"

        * "compress()"

        * "count()"

        * "cycle()"

        * "dropwhile()"

        * "filterfalse()"

        * "groupby()"

        * "islice()"

        * "pairwise()"

        * "permutations()"

        * "product()"

        * "repeat()"

        * "starmap()"

        * "takewhile()"

        * "tee()"

        * "zip_longest()"

      * Itertools 조리법

    * "functools" --- Higher-order functions and operations on
      callable objects

      * "cache()"

      * "cached_property()"

      * "cmp_to_key()"

      * "lru_cache()"

      * "total_ordering()"

      * "partial()"

      * "partialmethod"

      * "reduce()"

      * "singledispatch()"

      * "singledispatchmethod"

      * "update_wrapper()"

      * "wraps()"

      * "partial" 객체

        * "func"

        * "args"

        * "keywords"

    * "operator" --- Standard operators as functions

      * "lt()"

      * "le()"

      * "eq()"

      * "ne()"

      * "ge()"

      * "gt()"

      * "__lt__()"

      * "__le__()"

      * "__eq__()"

      * "__ne__()"

      * "__ge__()"

      * "__gt__()"

      * "not_()"

      * "__not__()"

      * "truth()"

      * "is_()"

      * "is_not()"

      * "abs()"

      * "__abs__()"

      * "add()"

      * "__add__()"

      * "and_()"

      * "__and__()"

      * "floordiv()"

      * "__floordiv__()"

      * "index()"

      * "__index__()"

      * "inv()"

      * "invert()"

      * "__inv__()"

      * "__invert__()"

      * "lshift()"

      * "__lshift__()"

      * "mod()"

      * "__mod__()"

      * "mul()"

      * "__mul__()"

      * "matmul()"

      * "__matmul__()"

      * "neg()"

      * "__neg__()"

      * "or_()"

      * "__or__()"

      * "pos()"

      * "__pos__()"

      * "pow()"

      * "__pow__()"

      * "rshift()"

      * "__rshift__()"

      * "sub()"

      * "__sub__()"

      * "truediv()"

      * "__truediv__()"

      * "xor()"

      * "__xor__()"

      * "concat()"

      * "__concat__()"

      * "contains()"

      * "__contains__()"

      * "countOf()"

      * "delitem()"

      * "__delitem__()"

      * "getitem()"

      * "__getitem__()"

      * "indexOf()"

      * "setitem()"

      * "__setitem__()"

      * "length_hint()"

      * "call()"

      * "__call__()"

      * "attrgetter()"

      * "itemgetter()"

      * "methodcaller()"

      * 연산자를 함수에 매핑하기

      * 제자리 연산자

        * "iadd()"

        * "__iadd__()"

        * "iand()"

        * "__iand__()"

        * "iconcat()"

        * "__iconcat__()"

        * "ifloordiv()"

        * "__ifloordiv__()"

        * "ilshift()"

        * "__ilshift__()"

        * "imod()"

        * "__imod__()"

        * "imul()"

        * "__imul__()"

        * "imatmul()"

        * "__imatmul__()"

        * "ior()"

        * "__ior__()"

        * "ipow()"

        * "__ipow__()"

        * "irshift()"

        * "__irshift__()"

        * "isub()"

        * "__isub__()"

        * "itruediv()"

        * "__itruediv__()"

        * "ixor()"

        * "__ixor__()"

  * 파일과 디렉터리 액세스

    * "pathlib" --- Object-oriented filesystem paths

      * 기본 사용

      * 순수한 경로

        * "PurePath"

        * "PurePosixPath"

        * "PureWindowsPath"

        * 일반 속성

        * 연산자

        * 개별 부분에 액세스하기

          * "parts"

        * 메서드와 프로퍼티

          * "drive"

          * "root"

          * "anchor"

          * "parents"

          * "parent"

          * "name"

          * "suffix"

          * "suffixes"

          * "stem"

          * "as_posix()"

          * "as_uri()"

          * "is_absolute()"

          * "is_relative_to()"

          * "is_reserved()"

          * "joinpath()"

          * "match()"

          * "relative_to()"

          * "with_name()"

          * "with_stem()"

          * "with_suffix()"

          * "with_segments()"

      * 구상 경로

        * "Path"

        * "PosixPath"

        * "WindowsPath"

        * Expanding and resolving paths

          * "home()"

          * "expanduser()"

          * "cwd()"

          * "absolute()"

          * "resolve()"

          * "readlink()"

        * Querying file type and status

          * "stat()"

          * "lstat()"

          * "exists()"

          * "is_file()"

          * "is_dir()"

          * "is_symlink()"

          * "is_junction()"

          * "is_mount()"

          * "is_socket()"

          * "is_fifo()"

          * "is_block_device()"

          * "is_char_device()"

          * "samefile()"

        * Reading and writing files

          * "open()"

          * "read_text()"

          * "read_bytes()"

          * "write_text()"

          * "write_bytes()"

        * Reading directories

          * "iterdir()"

          * "glob()"

          * "rglob()"

          * "walk()"

        * Creating files and directories

          * "touch()"

          * "mkdir()"

          * "symlink_to()"

          * "hardlink_to()"

        * Renaming and deleting

          * "rename()"

          * "replace()"

          * "unlink()"

          * "rmdir()"

        * Permissions and ownership

          * "owner()"

          * "group()"

          * "chmod()"

          * "lchmod()"

      * "os" 모듈에 있는 도구와 대조

    * "os.path" --- Common pathname manipulations

      * "abspath()"

      * "basename()"

      * "commonpath()"

      * "commonprefix()"

      * "dirname()"

      * "exists()"

      * "lexists()"

      * "expanduser()"

      * "expandvars()"

      * "getatime()"

      * "getmtime()"

      * "getctime()"

      * "getsize()"

      * "isabs()"

      * "isfile()"

      * "isdir()"

      * "isjunction()"

      * "islink()"

      * "ismount()"

      * "isdevdrive()"

      * "join()"

      * "normcase()"

      * "normpath()"

      * "realpath()"

      * "relpath()"

      * "samefile()"

      * "sameopenfile()"

      * "samestat()"

      * "split()"

      * "splitdrive()"

      * "splitroot()"

      * "splitext()"

      * "supports_unicode_filenames"

    * "fileinput" --- Iterate over lines from multiple input streams

      * "input()"

      * "filename()"

      * "fileno()"

      * "lineno()"

      * "filelineno()"

      * "isfirstline()"

      * "isstdin()"

      * "nextfile()"

      * "close()"

      * "FileInput"

      * "hook_compressed()"

      * "hook_encoded()"

    * "stat" --- Interpreting "stat()" results

      * "S_ISDIR()"

      * "S_ISCHR()"

      * "S_ISBLK()"

      * "S_ISREG()"

      * "S_ISFIFO()"

      * "S_ISLNK()"

      * "S_ISSOCK()"

      * "S_ISDOOR()"

      * "S_ISPORT()"

      * "S_ISWHT()"

      * "S_IMODE()"

      * "S_IFMT()"

      * "filemode()"

      * "ST_MODE"

      * "ST_INO"

      * "ST_DEV"

      * "ST_NLINK"

      * "ST_UID"

      * "ST_GID"

      * "ST_SIZE"

      * "ST_ATIME"

      * "ST_MTIME"

      * "ST_CTIME"

      * "S_IFSOCK"

      * "S_IFLNK"

      * "S_IFREG"

      * "S_IFBLK"

      * "S_IFDIR"

      * "S_IFCHR"

      * "S_IFIFO"

      * "S_IFDOOR"

      * "S_IFPORT"

      * "S_IFWHT"

      * "S_ISUID"

      * "S_ISGID"

      * "S_ISVTX"

      * "S_IRWXU"

      * "S_IRUSR"

      * "S_IWUSR"

      * "S_IXUSR"

      * "S_IRWXG"

      * "S_IRGRP"

      * "S_IWGRP"

      * "S_IXGRP"

      * "S_IRWXO"

      * "S_IROTH"

      * "S_IWOTH"

      * "S_IXOTH"

      * "S_ENFMT"

      * "S_IREAD"

      * "S_IWRITE"

      * "S_IEXEC"

      * "UF_NODUMP"

      * "UF_IMMUTABLE"

      * "UF_APPEND"

      * "UF_OPAQUE"

      * "UF_NOUNLINK"

      * "UF_COMPRESSED"

      * "UF_HIDDEN"

      * "SF_ARCHIVED"

      * "SF_IMMUTABLE"

      * "SF_APPEND"

      * "SF_NOUNLINK"

      * "SF_SNAPSHOT"

      * "FILE_ATTRIBUTE_ARCHIVE"

      * "FILE_ATTRIBUTE_COMPRESSED"

      * "FILE_ATTRIBUTE_DEVICE"

      * "FILE_ATTRIBUTE_DIRECTORY"

      * "FILE_ATTRIBUTE_ENCRYPTED"

      * "FILE_ATTRIBUTE_HIDDEN"

      * "FILE_ATTRIBUTE_INTEGRITY_STREAM"

      * "FILE_ATTRIBUTE_NORMAL"

      * "FILE_ATTRIBUTE_NOT_CONTENT_INDEXED"

      * "FILE_ATTRIBUTE_NO_SCRUB_DATA"

      * "FILE_ATTRIBUTE_OFFLINE"

      * "FILE_ATTRIBUTE_READONLY"

      * "FILE_ATTRIBUTE_REPARSE_POINT"

      * "FILE_ATTRIBUTE_SPARSE_FILE"

      * "FILE_ATTRIBUTE_SYSTEM"

      * "FILE_ATTRIBUTE_TEMPORARY"

      * "FILE_ATTRIBUTE_VIRTUAL"

      * "IO_REPARSE_TAG_SYMLINK"

      * "IO_REPARSE_TAG_MOUNT_POINT"

      * "IO_REPARSE_TAG_APPEXECLINK"

    * "filecmp" --- File and Directory Comparisons

      * "cmp()"

      * "cmpfiles()"

      * "clear_cache()"

      * "dircmp" 클래스

        * "dircmp"

          * "report()"

          * "report_partial_closure()"

          * "report_full_closure()"

          * "left"

          * "right"

          * "left_list"

          * "right_list"

          * "common"

          * "left_only"

          * "right_only"

          * "common_dirs"

          * "common_files"

          * "common_funny"

          * "same_files"

          * "diff_files"

          * "funny_files"

          * "subdirs"

        * "DEFAULT_IGNORES"

    * "tempfile" --- Generate temporary files and directories

      * "TemporaryFile()"

      * "NamedTemporaryFile()"

      * "SpooledTemporaryFile"

        * "rollover()"

      * "TemporaryDirectory"

        * "name"

        * "cleanup()"

      * "mkstemp()"

      * "mkdtemp()"

      * "gettempdir()"

      * "gettempdirb()"

      * "gettempprefix()"

      * "gettempprefixb()"

      * "tempdir"

      * 예

      * 폐지된 함수와 변수

        * "mktemp()"

    * "glob" --- Unix style pathname pattern expansion

      * "glob()"

      * "iglob()"

      * "escape()"

    * "fnmatch" --- Unix filename pattern matching

      * "fnmatch()"

      * "fnmatchcase()"

      * "filter()"

      * "translate()"

    * "linecache" --- Random access to text lines

      * "getline()"

      * "clearcache()"

      * "checkcache()"

      * "lazycache()"

    * "shutil" --- High-level file operations

      * 디렉터리와 파일 연산

        * "copyfileobj()"

        * "copyfile()"

        * "SameFileError"

        * "copymode()"

        * "copystat()"

        * "copy()"

        * "copy2()"

        * "ignore_patterns()"

        * "copytree()"

        * "rmtree()"

          * "avoids_symlink_attacks"

        * "move()"

        * "disk_usage()"

        * "chown()"

        * "which()"

        * "Error"

        * 플랫폼 의존적 효율적인 복사 연산

        * copytree 예

        * rmtree 예

      * 아카이브 연산

        * "make_archive()"

        * "get_archive_formats()"

        * "register_archive_format()"

        * "unregister_archive_format()"

        * "unpack_archive()"

        * "register_unpack_format()"

        * "unregister_unpack_format()"

        * "get_unpack_formats()"

        * 아카이브 예

        * *base_dir*을 사용한 아카이브 예

      * 출력 터미널의 크기 조회하기

        * "get_terminal_size()"

  * 데이터 지속성

    * "pickle" --- Python object serialization

      * 다른 파이썬 모듈과의 관계

        * "marshal" 과의 비교

        * "json" 과의 비교

      * 데이터 스트림 형식

      * 모듈 인터페이스

        * "HIGHEST_PROTOCOL"

        * "DEFAULT_PROTOCOL"

        * "dump()"

        * "dumps()"

        * "load()"

        * "loads()"

        * "PickleError"

        * "PicklingError"

        * "UnpicklingError"

        * "Pickler"

          * "dump()"

          * "persistent_id()"

          * "dispatch_table"

          * "reducer_override()"

          * "fast"

        * "Unpickler"

          * "load()"

          * "persistent_load()"

          * "find_class()"

        * "PickleBuffer"

          * "raw()"

          * "release()"

      * 어떤 것이 피클 되고 역 피클 될 수 있을까요?

      * 클래스 인스턴스 피클링

        * "__getnewargs_ex__()"

        * "__getnewargs__()"

        * "__getstate__()"

        * "__setstate__()"

        * "__reduce__()"

        * "__reduce_ex__()"

        * 외부 객체의 지속성

        * 디스패치 테이블

        * 상태 저장 객체 처리

      * 형, 함수 및 기타 객체에 대한 사용자 정의 환원

      * 아웃 오브 밴드 버퍼

        * 제공자 API

        * 소비자 API

        * 예제

      * 전역 제한하기

      * 성능

      * 예제

    * "copyreg" --- Register "pickle" support functions

      * "constructor()"

      * "pickle()"

      * 예제

    * "shelve" --- Python object persistence

      * "open()"

      * "sync()"

      * "close()"

      * 제약 사항

        * "Shelf"

        * "BsdDbShelf"

        * "DbfilenameShelf"

      * 예제

    * "marshal" --- Internal Python object serialization

      * "dump()"

      * "load()"

      * "dumps()"

      * "loads()"

      * "version"

    * "dbm" --- Interfaces to Unix "databases"

      * "error"

      * "whichdb()"

      * "open()"

      * "dbm.gnu" --- GNU database manager

        * "error"

        * "open()"

          * "open_flags"

          * "firstkey()"

          * "nextkey()"

          * "reorganize()"

          * "sync()"

          * "close()"

      * "dbm.ndbm" --- New Database Manager

        * "error"

        * "library"

        * "open()"

          * "close()"

      * "dbm.dumb" --- 이식성 있는 DBM 구현

        * "error"

        * "open()"

          * "sync()"

          * "close()"

    * "sqlite3" --- DB-API 2.0 interface for SQLite databases

      * Tutorial

      * Reference

        * Module functions

          * "connect()"

          * "complete_statement()"

          * "enable_callback_tracebacks()"

          * "register_adapter()"

          * "register_converter()"

        * Module constants

          * "LEGACY_TRANSACTION_CONTROL"

          * "PARSE_COLNAMES"

          * "PARSE_DECLTYPES"

          * "SQLITE_OK"

          * "SQLITE_DENY"

          * "SQLITE_IGNORE"

          * "apilevel"

          * "paramstyle"

          * "sqlite_version"

          * "sqlite_version_info"

          * "threadsafety"

          * "version"

          * "version_info"

          * "SQLITE_DBCONFIG_DEFENSIVE"

          * "SQLITE_DBCONFIG_DQS_DDL"

          * "SQLITE_DBCONFIG_DQS_DML"

          * "SQLITE_DBCONFIG_ENABLE_FKEY"

          * "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER"

          * "SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION"

          * "SQLITE_DBCONFIG_ENABLE_QPSG"

          * "SQLITE_DBCONFIG_ENABLE_TRIGGER"

          * "SQLITE_DBCONFIG_ENABLE_VIEW"

          * "SQLITE_DBCONFIG_LEGACY_ALTER_TABLE"

          * "SQLITE_DBCONFIG_LEGACY_FILE_FORMAT"

          * "SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE"

          * "SQLITE_DBCONFIG_RESET_DATABASE"

          * "SQLITE_DBCONFIG_TRIGGER_EQP"

          * "SQLITE_DBCONFIG_TRUSTED_SCHEMA"

          * "SQLITE_DBCONFIG_WRITABLE_SCHEMA"

        * Connection objects

          * "Connection"

            * "cursor()"

            * "blobopen()"

            * "commit()"

            * "rollback()"

            * "close()"

            * "execute()"

            * "executemany()"

            * "executescript()"

            * "create_function()"

            * "create_aggregate()"

            * "create_window_function()"

            * "create_collation()"

            * "interrupt()"

            * "set_authorizer()"

            * "set_progress_handler()"

            * "set_trace_callback()"

            * "enable_load_extension()"

            * "load_extension()"

            * "iterdump()"

            * "backup()"

            * "getlimit()"

            * "setlimit()"

            * "getconfig()"

            * "setconfig()"

            * "serialize()"

            * "deserialize()"

            * "autocommit"

            * "in_transaction"

            * "isolation_level"

            * "row_factory"

            * "text_factory"

            * "total_changes"

        * Cursor objects

          * "Cursor"

            * "execute()"

            * "executemany()"

            * "executescript()"

            * "fetchone()"

            * "fetchmany()"

            * "fetchall()"

            * "close()"

            * "setinputsizes()"

            * "setoutputsize()"

            * "arraysize"

            * "connection"

            * "description"

            * "lastrowid"

            * "rowcount"

            * "row_factory"

        * Row objects

          * "Row"

            * "keys()"

        * Blob objects

          * "Blob"

            * "close()"

            * "read()"

            * "write()"

            * "tell()"

            * "seek()"

        * PrepareProtocol objects

          * "PrepareProtocol"

        * 예외

          * "Warning"

          * "Error"

            * "sqlite_errorcode"

            * "sqlite_errorname"

          * "InterfaceError"

          * "DatabaseError"

          * "DataError"

          * "OperationalError"

          * "IntegrityError"

          * "InternalError"

          * "ProgrammingError"

          * "NotSupportedError"

        * SQLite 와 파이썬 형

        * Default adapters and converters (deprecated)

        * Command-line interface

      * How-to guides

        * How to use placeholders to bind values in SQL queries

        * How to adapt custom Python types to SQLite values

          * How to write adaptable objects

          * How to register adapter callables

        * How to convert SQLite values to custom Python types

        * Adapter and converter recipes

        * How to use connection shortcut methods

        * How to use the connection context manager

        * How to work with SQLite URIs

        * How to create and use row factories

        * How to handle non-UTF-8 text encodings

      * Explanation

        * Transaction control

          * Transaction control via the "autocommit" attribute

          * Transaction control via the "isolation_level" attribute

  * 데이터 압축 및 보관

    * "zlib" --- Compression compatible with **gzip**

      * "error"

      * "adler32()"

      * "compress()"

      * "compressobj()"

      * "crc32()"

      * "decompress()"

      * "decompressobj()"

      * "compress()"

      * "flush()"

      * "copy()"

      * "unused_data"

      * "unconsumed_tail"

      * "eof"

      * "decompress()"

      * "flush()"

      * "copy()"

      * "ZLIB_VERSION"

      * "ZLIB_RUNTIME_VERSION"

    * "gzip" --- Support for **gzip** files

      * "open()"

      * "BadGzipFile"

      * "GzipFile"

        * "peek()"

        * "mtime"

        * "name"

      * "compress()"

      * "decompress()"

      * 사용 예

      * 명령 줄 인터페이스

        * 명령 줄 옵션

    * "bz2" --- Support for **bzip2** compression

      * 파일 압축(해제)

        * "open()"

        * "BZ2File"

          * "peek()"

          * "fileno()"

          * "readable()"

          * "seekable()"

          * "writable()"

          * "read1()"

          * "readinto()"

      * 증분 압축(해제)

        * "BZ2Compressor"

          * "compress()"

          * "flush()"

        * "BZ2Decompressor"

          * "decompress()"

          * "eof"

          * "unused_data"

          * "needs_input"

      * 일괄 압축(해제)

        * "compress()"

        * "decompress()"

      * 사용 예

    * "lzma" --- Compression using the LZMA algorithm

      * "LZMAError"

      * 압축 파일 읽기와 쓰기

        * "open()"

        * "LZMAFile"

          * "peek()"

      * 메모리에서의 데이터 압축과 압축 해제

        * "LZMACompressor"

          * "compress()"

          * "flush()"

        * "LZMADecompressor"

          * "decompress()"

          * "check"

          * "eof"

          * "unused_data"

          * "needs_input"

        * "compress()"

        * "decompress()"

      * 기타

        * "is_check_supported()"

      * 사용자 정의 필터 체인 지정

      * 예

    * "zipfile" --- Work with ZIP archives

      * "BadZipFile"

      * "BadZipfile"

      * "LargeZipFile"

      * "ZipInfo"

      * "is_zipfile()"

      * "ZIP_STORED"

      * "ZIP_DEFLATED"

      * "ZIP_BZIP2"

      * "ZIP_LZMA"

      * ZipFile 객체

        * "ZipFile"

        * "close()"

        * "getinfo()"

        * "infolist()"

        * "namelist()"

        * "open()"

        * "extract()"

        * "extractall()"

        * "printdir()"

        * "setpassword()"

        * "read()"

        * "testzip()"

        * "write()"

        * "writestr()"

        * "mkdir()"

        * "filename"

        * "debug"

        * "comment"

      * Path 객체

        * "Path"

        * "name"

        * "open()"

        * "iterdir()"

        * "is_dir()"

        * "is_file()"

        * "exists()"

        * "suffix"

        * "stem"

        * "suffixes"

        * "read_text()"

        * "read_bytes()"

        * "joinpath()"

      * PyZipFile 객체

        * "PyZipFile"

          * "writepy()"

      * ZipInfo 객체

        * "from_file()"

        * "is_dir()"

        * "filename"

        * "date_time"

        * "compress_type"

        * "comment"

        * "extra"

        * "create_system"

        * "create_version"

        * "extract_version"

        * "reserved"

        * "flag_bits"

        * "volume"

        * "internal_attr"

        * "external_attr"

        * "header_offset"

        * "CRC"

        * "compress_size"

        * "file_size"

      * 명령 줄 인터페이스

        * 명령 줄 옵션

      * 압축 해제 함정

        * 파일 자체에서

        * 파일 시스템 제한

        * 자원 제한

        * 중단

        * 추출의 기본 동작

    * "tarfile" --- Read and write tar archive files

      * "open()"

      * "is_tarfile()"

      * "TarError"

      * "ReadError"

      * "CompressionError"

      * "StreamError"

      * "ExtractError"

      * "HeaderError"

      * "FilterError"

        * "tarinfo"

      * "AbsolutePathError"

      * "OutsideDestinationError"

      * "SpecialFileError"

      * "AbsoluteLinkError"

      * "LinkOutsideDestinationError"

      * "ENCODING"

      * "REGTYPE"

      * "AREGTYPE"

      * "LNKTYPE"

      * "SYMTYPE"

      * "CHRTYPE"

      * "BLKTYPE"

      * "DIRTYPE"

      * "FIFOTYPE"

      * "CONTTYPE"

      * "GNUTYPE_LONGNAME"

      * "GNUTYPE_LONGLINK"

      * "GNUTYPE_SPARSE"

      * "USTAR_FORMAT"

      * "GNU_FORMAT"

      * "PAX_FORMAT"

      * "DEFAULT_FORMAT"

      * TarFile 객체

        * "TarFile"

        * "open()"

        * "getmember()"

        * "getmembers()"

        * "getnames()"

        * "list()"

        * "next()"

        * "extractall()"

        * "extract()"

        * "extractfile()"

        * "errorlevel"

        * "extraction_filter"

        * "add()"

        * "addfile()"

        * "gettarinfo()"

        * "close()"

        * "pax_headers"

      * TarInfo 객체

        * "TarInfo"

        * "frombuf()"

        * "fromtarfile()"

        * "tobuf()"

        * "name"

        * "size"

        * "mtime"

        * "mode"

        * "type"

        * "linkname"

        * "uid"

        * "gid"

        * "uname"

        * "gname"

        * "chksum"

        * "devmajor"

        * "devminor"

        * "offset"

        * "offset_data"

        * "sparse"

        * "pax_headers"

        * "replace()"

        * "isfile()"

        * "isreg()"

        * "isdir()"

        * "issym()"

        * "islnk()"

        * "ischr()"

        * "isblk()"

        * "isfifo()"

        * "isdev()"

      * Extraction filters

        * Default named filters

          * "fully_trusted_filter()"

          * "tar_filter()"

          * "data_filter()"

        * Filter errors

        * Hints for further verification

        * Supporting older Python versions

        * Stateful extraction filter example

      * 명령 줄 인터페이스

        * 명령 줄 옵션

      * 예

      * 지원되는 tar 형식

      * 유니코드 문제

  * 파일 형식

    * "csv" --- CSV File Reading and Writing

      * 모듈 내용

        * "reader()"

        * "writer()"

        * "register_dialect()"

        * "unregister_dialect()"

        * "get_dialect()"

        * "list_dialects()"

        * "field_size_limit()"

        * "DictReader"

        * "DictWriter"

        * "Dialect"

        * "excel"

        * "excel_tab"

        * "unix_dialect"

        * "Sniffer"

          * "sniff()"

          * "has_header()"

        * "QUOTE_ALL"

        * "QUOTE_MINIMAL"

        * "QUOTE_NONNUMERIC"

        * "QUOTE_NONE"

        * "QUOTE_NOTNULL"

        * "QUOTE_STRINGS"

        * "Error"

      * 방언과 포매팅 파라미터

        * "delimiter"

        * "doublequote"

        * "escapechar"

        * "lineterminator"

        * "quotechar"

        * "quoting"

        * "skipinitialspace"

        * "strict"

      * 판독기 객체

        * "__next__()"

        * "dialect"

        * "line_num"

        * "fieldnames"

      * 기록기 객체

        * "writerow()"

        * "writerows()"

        * "dialect"

        * "writeheader()"

      * 예제

    * "configparser" --- Configuration file parser

      * 빠른 시작

      * 지원되는 데이터형

      * 대체 값

      * 지원되는 INI 파일 구조

      * 값의 보간

        * "BasicInterpolation"

        * "ExtendedInterpolation"

      * 매핑 프로토콜 액세스

      * 구문 분석기 동작 사용자 정의

        * "BOOLEAN_STATES"

        * "SECTCRE"

      * 레거시 API 예제

      * ConfigParser 객체

        * "ConfigParser"

          * "defaults()"

          * "sections()"

          * "add_section()"

          * "has_section()"

          * "options()"

          * "has_option()"

          * "read()"

          * "read_file()"

          * "read_string()"

          * "read_dict()"

          * "get()"

          * "getint()"

          * "getfloat()"

          * "getboolean()"

          * "items()"

          * "set()"

          * "write()"

          * "remove_option()"

          * "remove_section()"

          * "optionxform()"

        * "MAX_INTERPOLATION_DEPTH"

      * RawConfigParser 객체

        * "RawConfigParser"

          * "add_section()"

          * "set()"

      * 예외

        * "Error"

        * "NoSectionError"

        * "DuplicateSectionError"

        * "DuplicateOptionError"

        * "NoOptionError"

        * "InterpolationError"

        * "InterpolationDepthError"

        * "InterpolationMissingOptionError"

        * "InterpolationSyntaxError"

        * "MissingSectionHeaderError"

        * "ParsingError"

    * "tomllib" --- Parse TOML files

      * "load()"

      * "loads()"

      * "TOMLDecodeError"

      * Examples

      * Conversion Table

    * "netrc" --- netrc file processing

      * "netrc"

      * "NetrcParseError"

        * "msg"

        * "filename"

        * "lineno"

      * netrc 객체

        * "authenticators()"

        * "__repr__()"

        * "hosts"

        * "macros"

    * "plistlib" --- Generate and parse Apple ".plist" files

      * "load()"

      * "loads()"

      * "dump()"

      * "dumps()"

      * "UID"

      * "FMT_XML"

      * "FMT_BINARY"

      * 예제

  * 암호화 서비스

    * "hashlib" --- Secure hashes and message digests

      * 해시 알고리즘

      * Usage

      * Constructors

        * "new()"

        * "md5()"

        * "sha1()"

        * "sha224()"

        * "sha256()"

        * "sha384()"

        * "sha512()"

        * "sha3_224()"

        * "sha3_256()"

        * "sha3_384()"

        * "sha3_512()"

      * Attributes

        * "algorithms_guaranteed"

        * "algorithms_available"

      * Hash Objects

        * "digest_size"

        * "block_size"

        * "name"

        * "update()"

        * "digest()"

        * "hexdigest()"

        * "copy()"

      * SHAKE 가변 길이 요약

        * "shake_128()"

        * "shake_256()"

        * "digest()"

        * "hexdigest()"

      * File hashing

        * "file_digest()"

      * 키 파생

        * "pbkdf2_hmac()"

        * "scrypt()"

      * BLAKE2

        * 해시 객체 만들기

          * "blake2b()"

          * "blake2s()"

        * 상수

          * "SALT_SIZE"

          * "SALT_SIZE"

          * "PERSON_SIZE"

          * "PERSON_SIZE"

          * "MAX_KEY_SIZE"

          * "MAX_KEY_SIZE"

          * "MAX_DIGEST_SIZE"

          * "MAX_DIGEST_SIZE"

        * 예

          * 간단한 해싱

          * 다른 요약 크기 사용하기

          * 키 해싱

          * 무작위 해싱

          * 개인화

          * 트리 모드

        * 크레딧

    * "hmac" --- Keyed-Hashing for Message Authentication

      * "new()"

      * "digest()"

      * "update()"

      * "digest()"

      * "hexdigest()"

      * "copy()"

      * "digest_size"

      * "block_size"

      * "name"

      * "compare_digest()"

    * "secrets" --- Generate secure random numbers for managing
      secrets

      * 난수

        * "SystemRandom"

        * "choice()"

        * "randbelow()"

        * "randbits()"

      * 토큰 생성

        * "token_bytes()"

        * "token_hex()"

        * "token_urlsafe()"

        * 토큰은 몇 바이트를 사용해야 합니까?

      * 기타 함수

        * "compare_digest()"

      * 조리법과 모범 사례

  * 일반 운영 체제 서비스

    * "os" --- Miscellaneous operating system interfaces

      * "error"

      * "name"

      * 파일명, 명령 줄 인자 및 환경 변수

      * Python UTF-8 Mode

      * 프로세스 매개 변수

        * "ctermid()"

        * "environ"

        * "environb"

        * "fsencode()"

        * "fsdecode()"

        * "fspath()"

        * "PathLike"

          * "__fspath__()"

        * "getenv()"

        * "getenvb()"

        * "get_exec_path()"

        * "getegid()"

        * "geteuid()"

        * "getgid()"

        * "getgrouplist()"

        * "getgroups()"

        * "getlogin()"

        * "getpgid()"

        * "getpgrp()"

        * "getpid()"

        * "getppid()"

        * "getpriority()"

        * "PRIO_PROCESS"

        * "PRIO_PGRP"

        * "PRIO_USER"

        * "PRIO_DARWIN_THREAD"

        * "PRIO_DARWIN_PROCESS"

        * "PRIO_DARWIN_BG"

        * "PRIO_DARWIN_NONUI"

        * "getresuid()"

        * "getresgid()"

        * "getuid()"

        * "initgroups()"

        * "putenv()"

        * "setegid()"

        * "seteuid()"

        * "setgid()"

        * "setgroups()"

        * "setns()"

        * "setpgrp()"

        * "setpgid()"

        * "setpriority()"

        * "setregid()"

        * "setresgid()"

        * "setresuid()"

        * "setreuid()"

        * "getsid()"

        * "setsid()"

        * "setuid()"

        * "strerror()"

        * "supports_bytes_environ"

        * "umask()"

        * "uname()"

        * "unsetenv()"

        * "unshare()"

        * "CLONE_FILES"

        * "CLONE_FS"

        * "CLONE_NEWCGROUP"

        * "CLONE_NEWIPC"

        * "CLONE_NEWNET"

        * "CLONE_NEWNS"

        * "CLONE_NEWPID"

        * "CLONE_NEWTIME"

        * "CLONE_NEWUSER"

        * "CLONE_NEWUTS"

        * "CLONE_SIGHAND"

        * "CLONE_SYSVSEM"

        * "CLONE_THREAD"

        * "CLONE_VM"

      * 파일 객체 생성

        * "fdopen()"

      * 파일 기술자 연산

        * "close()"

        * "closerange()"

        * "copy_file_range()"

        * "device_encoding()"

        * "dup()"

        * "dup2()"

        * "fchmod()"

        * "fchown()"

        * "fdatasync()"

        * "fpathconf()"

        * "fstat()"

        * "fstatvfs()"

        * "fsync()"

        * "ftruncate()"

        * "get_blocking()"

        * "isatty()"

        * "lockf()"

        * "F_LOCK"

        * "F_TLOCK"

        * "F_ULOCK"

        * "F_TEST"

        * "login_tty()"

        * "lseek()"

        * "SEEK_SET"

        * "SEEK_CUR"

        * "SEEK_END"

        * "SEEK_HOLE"

        * "SEEK_DATA"

        * "open()"

        * "O_RDONLY"

        * "O_WRONLY"

        * "O_RDWR"

        * "O_APPEND"

        * "O_CREAT"

        * "O_EXCL"

        * "O_TRUNC"

        * "O_DSYNC"

        * "O_RSYNC"

        * "O_SYNC"

        * "O_NDELAY"

        * "O_NONBLOCK"

        * "O_NOCTTY"

        * "O_CLOEXEC"

        * "O_BINARY"

        * "O_NOINHERIT"

        * "O_SHORT_LIVED"

        * "O_TEMPORARY"

        * "O_RANDOM"

        * "O_SEQUENTIAL"

        * "O_TEXT"

        * "O_EVTONLY"

        * "O_FSYNC"

        * "O_SYMLINK"

        * "O_NOFOLLOW_ANY"

        * "O_ASYNC"

        * "O_DIRECT"

        * "O_DIRECTORY"

        * "O_NOFOLLOW"

        * "O_NOATIME"

        * "O_PATH"

        * "O_TMPFILE"

        * "O_SHLOCK"

        * "O_EXLOCK"

        * "openpty()"

        * "pipe()"

        * "pipe2()"

        * "posix_fallocate()"

        * "posix_fadvise()"

        * "POSIX_FADV_NORMAL"

        * "POSIX_FADV_SEQUENTIAL"

        * "POSIX_FADV_RANDOM"

        * "POSIX_FADV_NOREUSE"

        * "POSIX_FADV_WILLNEED"

        * "POSIX_FADV_DONTNEED"

        * "pread()"

        * "preadv()"

        * "RWF_NOWAIT"

        * "RWF_HIPRI"

        * "pwrite()"

        * "pwritev()"

        * "RWF_DSYNC"

        * "RWF_SYNC"

        * "RWF_APPEND"

        * "read()"

        * "sendfile()"

        * "SF_NODISKIO"

        * "SF_MNOWAIT"

        * "SF_SYNC"

        * "SF_NOCACHE"

        * "set_blocking()"

        * "splice()"

        * "SPLICE_F_MOVE"

        * "SPLICE_F_NONBLOCK"

        * "SPLICE_F_MORE"

        * "readv()"

        * "tcgetpgrp()"

        * "tcsetpgrp()"

        * "ttyname()"

        * "write()"

        * "writev()"

        * 터미널의 크기 조회하기

          * "get_terminal_size()"

          * "terminal_size"

            * "columns"

            * "lines"

        * 파일 기술자의 상속

          * "get_inheritable()"

          * "set_inheritable()"

          * "get_handle_inheritable()"

          * "set_handle_inheritable()"

      * 파일과 디렉터리

        * "access()"

        * "F_OK"

        * "R_OK"

        * "W_OK"

        * "X_OK"

        * "chdir()"

        * "chflags()"

        * "chmod()"

        * "chown()"

        * "chroot()"

        * "fchdir()"

        * "getcwd()"

        * "getcwdb()"

        * "lchflags()"

        * "lchmod()"

        * "lchown()"

        * "link()"

        * "listdir()"

        * "listdrives()"

        * "listmounts()"

        * "listvolumes()"

        * "lstat()"

        * "mkdir()"

        * "makedirs()"

        * "mkfifo()"

        * "mknod()"

        * "major()"

        * "minor()"

        * "makedev()"

        * "pathconf()"

        * "pathconf_names"

        * "readlink()"

        * "remove()"

        * "removedirs()"

        * "rename()"

        * "renames()"

        * "replace()"

        * "rmdir()"

        * "scandir()"

          * "close()"

        * "DirEntry"

          * "name"

          * "path"

          * "inode()"

          * "is_dir()"

          * "is_file()"

          * "is_symlink()"

          * "is_junction()"

          * "stat()"

        * "stat()"

        * "stat_result"

          * "st_mode"

          * "st_ino"

          * "st_dev"

          * "st_nlink"

          * "st_uid"

          * "st_gid"

          * "st_size"

          * "st_atime"

          * "st_mtime"

          * "st_ctime"

          * "st_atime_ns"

          * "st_mtime_ns"

          * "st_ctime_ns"

          * "st_birthtime"

          * "st_birthtime_ns"

          * "st_blocks"

          * "st_blksize"

          * "st_rdev"

          * "st_flags"

          * "st_gen"

          * "st_fstype"

          * "st_rsize"

          * "st_creator"

          * "st_type"

          * "st_file_attributes"

          * "st_reparse_tag"

        * "statvfs()"

        * "supports_dir_fd"

        * "supports_effective_ids"

        * "supports_fd"

        * "supports_follow_symlinks"

        * "symlink()"

        * "sync()"

        * "truncate()"

        * "unlink()"

        * "utime()"

        * "walk()"

        * "fwalk()"

        * "memfd_create()"

        * "MFD_CLOEXEC"

        * "MFD_ALLOW_SEALING"

        * "MFD_HUGETLB"

        * "MFD_HUGE_SHIFT"

        * "MFD_HUGE_MASK"

        * "MFD_HUGE_64KB"

        * "MFD_HUGE_512KB"

        * "MFD_HUGE_1MB"

        * "MFD_HUGE_2MB"

        * "MFD_HUGE_8MB"

        * "MFD_HUGE_16MB"

        * "MFD_HUGE_32MB"

        * "MFD_HUGE_256MB"

        * "MFD_HUGE_512MB"

        * "MFD_HUGE_1GB"

        * "MFD_HUGE_2GB"

        * "MFD_HUGE_16GB"

        * "eventfd()"

        * "eventfd_read()"

        * "eventfd_write()"

        * "EFD_CLOEXEC"

        * "EFD_NONBLOCK"

        * "EFD_SEMAPHORE"

        * 리눅스 확장 어트리뷰트

          * "getxattr()"

          * "listxattr()"

          * "removexattr()"

          * "setxattr()"

          * "XATTR_SIZE_MAX"

          * "XATTR_CREATE"

          * "XATTR_REPLACE"

      * 프로세스 관리

        * "abort()"

        * "add_dll_directory()"

        * "execl()"

        * "execle()"

        * "execlp()"

        * "execlpe()"

        * "execv()"

        * "execve()"

        * "execvp()"

        * "execvpe()"

        * "_exit()"

        * "EX_OK"

        * "EX_USAGE"

        * "EX_DATAERR"

        * "EX_NOINPUT"

        * "EX_NOUSER"

        * "EX_NOHOST"

        * "EX_UNAVAILABLE"

        * "EX_SOFTWARE"

        * "EX_OSERR"

        * "EX_OSFILE"

        * "EX_CANTCREAT"

        * "EX_IOERR"

        * "EX_TEMPFAIL"

        * "EX_PROTOCOL"

        * "EX_NOPERM"

        * "EX_CONFIG"

        * "EX_NOTFOUND"

        * "fork()"

        * "forkpty()"

        * "kill()"

        * "killpg()"

        * "nice()"

        * "pidfd_open()"

          * "PIDFD_NONBLOCK"

        * "plock()"

        * "popen()"

        * "posix_spawn()"

          * "POSIX_SPAWN_OPEN"

          * "POSIX_SPAWN_CLOSE"

          * "POSIX_SPAWN_DUP2"

        * "posix_spawnp()"

        * "register_at_fork()"

        * "spawnl()"

        * "spawnle()"

        * "spawnlp()"

        * "spawnlpe()"

        * "spawnv()"

        * "spawnve()"

        * "spawnvp()"

        * "spawnvpe()"

        * "P_NOWAIT"

        * "P_NOWAITO"

        * "P_WAIT"

        * "P_DETACH"

        * "P_OVERLAY"

        * "startfile()"

        * "system()"

        * "times()"

        * "wait()"

        * "waitid()"

        * "waitpid()"

        * "wait3()"

        * "wait4()"

        * "P_PID"

        * "P_PGID"

        * "P_ALL"

        * "P_PIDFD"

        * "WCONTINUED"

        * "WEXITED"

        * "WSTOPPED"

        * "WUNTRACED"

        * "WNOHANG"

        * "WNOWAIT"

        * "CLD_EXITED"

        * "CLD_KILLED"

        * "CLD_DUMPED"

        * "CLD_TRAPPED"

        * "CLD_STOPPED"

        * "CLD_CONTINUED"

        * "waitstatus_to_exitcode()"

        * "WCOREDUMP()"

        * "WIFCONTINUED()"

        * "WIFSTOPPED()"

        * "WIFSIGNALED()"

        * "WIFEXITED()"

        * "WEXITSTATUS()"

        * "WSTOPSIG()"

        * "WTERMSIG()"

      * 스케줄러에 대한 인터페이스

        * "SCHED_OTHER"

        * "SCHED_BATCH"

        * "SCHED_IDLE"

        * "SCHED_SPORADIC"

        * "SCHED_FIFO"

        * "SCHED_RR"

        * "SCHED_RESET_ON_FORK"

        * "sched_param"

          * "sched_priority"

        * "sched_get_priority_min()"

        * "sched_get_priority_max()"

        * "sched_setscheduler()"

        * "sched_getscheduler()"

        * "sched_setparam()"

        * "sched_getparam()"

        * "sched_rr_get_interval()"

        * "sched_yield()"

        * "sched_setaffinity()"

        * "sched_getaffinity()"

      * 기타 시스템 정보

        * "confstr()"

        * "confstr_names"

        * "cpu_count()"

        * "getloadavg()"

        * "sysconf()"

        * "sysconf_names"

        * "curdir"

        * "pardir"

        * "sep"

        * "altsep"

        * "extsep"

        * "pathsep"

        * "defpath"

        * "linesep"

        * "devnull"

        * "RTLD_LAZY"

        * "RTLD_NOW"

        * "RTLD_GLOBAL"

        * "RTLD_LOCAL"

        * "RTLD_NODELETE"

        * "RTLD_NOLOAD"

        * "RTLD_DEEPBIND"

      * 난수

        * "getrandom()"

        * "urandom()"

        * "GRND_NONBLOCK"

        * "GRND_RANDOM"

    * "io" --- Core tools for working with streams

      * 개요

        * 텍스트 I/O

        * 바이너리 I/O

        * 원시 I/O

      * Text Encoding

        * Opt-in EncodingWarning

      * 고수준 모듈 인터페이스

        * "DEFAULT_BUFFER_SIZE"

        * "open()"

        * "open_code()"

        * "text_encoding()"

        * "BlockingIOError"

        * "UnsupportedOperation"

      * 클래스 위계

        * I/O 베이스 클래스

          * "IOBase"

            * "close()"

            * "closed"

            * "fileno()"

            * "flush()"

            * "isatty()"

            * "readable()"

            * "readline()"

            * "readlines()"

            * "seek()"

            * "seekable()"

            * "tell()"

            * "truncate()"

            * "writable()"

            * "writelines()"

            * "__del__()"

          * "RawIOBase"

            * "read()"

            * "readall()"

            * "readinto()"

            * "write()"

          * "BufferedIOBase"

            * "raw"

            * "detach()"

            * "read()"

            * "read1()"

            * "readinto()"

            * "readinto1()"

            * "write()"

        * 원시 파일 I/O

          * "FileIO"

            * "mode"

            * "name"

        * 버퍼링 된 스트림

          * "BytesIO"

            * "getbuffer()"

            * "getvalue()"

            * "read1()"

            * "readinto1()"

          * "BufferedReader"

            * "peek()"

            * "read()"

            * "read1()"

          * "BufferedWriter"

            * "flush()"

            * "write()"

          * "BufferedRandom"

          * "BufferedRWPair"

        * 텍스트 I/O

          * "TextIOBase"

            * "encoding"

            * "errors"

            * "newlines"

            * "buffer"

            * "detach()"

            * "read()"

            * "readline()"

            * "seek()"

            * "tell()"

            * "write()"

          * "TextIOWrapper"

            * "line_buffering"

            * "write_through"

            * "reconfigure()"

            * "seek()"

            * "tell()"

          * "StringIO"

            * "getvalue()"

          * "IncrementalNewlineDecoder"

      * 성능

        * 바이너리 I/O

        * 텍스트 I/O

        * 다중 스레드

        * 재진입

    * "time" --- Time access and conversions

      * 함수

        * "asctime()"

        * "pthread_getcpuclockid()"

        * "clock_getres()"

        * "clock_gettime()"

        * "clock_gettime_ns()"

        * "clock_settime()"

        * "clock_settime_ns()"

        * "ctime()"

        * "get_clock_info()"

        * "gmtime()"

        * "localtime()"

        * "mktime()"

        * "monotonic()"

        * "monotonic_ns()"

        * "perf_counter()"

        * "perf_counter_ns()"

        * "process_time()"

        * "process_time_ns()"

        * "sleep()"

        * "strftime()"

        * "strptime()"

        * "struct_time"

          * "tm_year"

          * "tm_mon"

          * "tm_mday"

          * "tm_hour"

          * "tm_min"

          * "tm_sec"

          * "tm_wday"

          * "tm_yday"

          * "tm_isdst"

          * "tm_zone"

          * "tm_gmtoff"

        * "time()"

        * "time_ns()"

        * "thread_time()"

        * "thread_time_ns()"

        * "tzset()"

      * 시계 ID 상수

        * "CLOCK_BOOTTIME"

        * "CLOCK_HIGHRES"

        * "CLOCK_MONOTONIC"

        * "CLOCK_MONOTONIC_RAW"

        * "CLOCK_PROCESS_CPUTIME_ID"

        * "CLOCK_PROF"

        * "CLOCK_TAI"

        * "CLOCK_THREAD_CPUTIME_ID"

        * "CLOCK_UPTIME"

        * "CLOCK_UPTIME_RAW"

        * "CLOCK_REALTIME"

      * 시간대 상수

        * "altzone"

        * "daylight"

        * "timezone"

        * "tzname"

    * "argparse" --- Parser for command-line options, arguments and
      subcommands

      * ArgumentParser 객체

        * "ArgumentParser"

        * prog

        * usage

        * description

        * epilog

        * parents

        * formatter_class

          * "RawDescriptionHelpFormatter"

          * "RawTextHelpFormatter"

          * "ArgumentDefaultsHelpFormatter"

          * "MetavarTypeHelpFormatter"

        * prefix_chars

        * fromfile_prefix_chars

        * argument_default

        * allow_abbrev

        * conflict_handler

        * add_help

        * exit_on_error

      * add_argument() 메서드

        * "add_argument()"

        * name or flags

        * action

          * "BooleanOptionalAction"

        * nargs

        * const

        * default

        * type

        * choices

        * required

        * help

        * metavar

        * dest

        * Action 클래스

          * "Action"

            * "__call__()"

            * "format_usage()"

      * parse_args() 메서드

        * "parse_args()"

        * 옵션값 문법

        * 잘못된 인자

        * "-" 를 포함하는 인자들

        * 인자 약어 (접두사 일치)

        * "sys.argv" 너머

        * Namespace 객체

          * "Namespace"

      * 기타 유틸리티

        * 부속 명령

          * "add_subparsers()"

        * FileType 객체

          * "FileType"

        * 인자 그룹

          * "add_argument_group()"

        * 상호 배제

          * "add_mutually_exclusive_group()"

        * 파서 기본값

          * "set_defaults()"

          * "get_default()"

        * 도움말 인쇄

          * "print_usage()"

          * "print_help()"

          * "format_usage()"

          * "format_help()"

        * 부분 파싱

          * "parse_known_args()"

        * 파일 파싱 사용자 정의

          * "convert_arg_line_to_args()"

        * 종료 메서드

          * "exit()"

          * "error()"

        * 혼합 파싱

          * "parse_intermixed_args()"

          * "parse_known_intermixed_args()"

        * Registering custom types or actions

          * "register()"

      * Exceptions

        * "ArgumentError"

        * "ArgumentTypeError"

        * Argparse 자습서

          * 개념

          * 기본

          * 위치 인자 소개

          * 옵션 인자 소개

            * 짧은 옵션

          * 위치 및 옵션 인자 결합하기

          * 조금 더 발전시키기

            * Specifying ambiguous arguments

            * 충돌하는 옵션들

          * How to translate the argparse output

          * Custom type converters

          * 맺음말

        * Upgrading optparse code

    * "getopt" --- C-style parser for command line options

      * "getopt()"

      * "gnu_getopt()"

      * "GetoptError"

      * "error"

    * "logging" --- Logging facility for Python

      * Logger 객체

        * "Logger"

          * "name"

          * "level"

          * "parent"

          * "propagate"

          * "handlers"

          * "disabled"

          * "setLevel()"

          * "isEnabledFor()"

          * "getEffectiveLevel()"

          * "getChild()"

          * "getChildren()"

          * "debug()"

          * "info()"

          * "warning()"

          * "error()"

          * "critical()"

          * "log()"

          * "exception()"

          * "addFilter()"

          * "removeFilter()"

          * "filter()"

          * "addHandler()"

          * "removeHandler()"

          * "findCaller()"

          * "handle()"

          * "makeRecord()"

          * "hasHandlers()"

      * 로깅 수준

        * "NOTSET"

        * "DEBUG"

        * "INFO"

        * "WARNING"

        * "ERROR"

        * "CRITICAL"

      * Handler 객체

        * "Handler"

          * "__init__()"

          * "createLock()"

          * "acquire()"

          * "release()"

          * "setLevel()"

          * "setFormatter()"

          * "addFilter()"

          * "removeFilter()"

          * "filter()"

          * "flush()"

          * "close()"

          * "handle()"

          * "handleError()"

          * "format()"

          * "emit()"

      * Formatter 객체

        * "Formatter"

          * "format()"

          * "formatTime()"

          * "formatException()"

          * "formatStack()"

        * "BufferingFormatter"

          * "formatHeader()"

          * "formatFooter()"

          * "format()"

      * Filter 객체

        * "Filter"

          * "filter()"

      * LogRecord 객체

        * "LogRecord"

          * "getMessage()"

      * LogRecord 어트리뷰트

      * LoggerAdapter 객체

        * "LoggerAdapter"

          * "process()"

          * "manager"

          * "_log"

      * 스레드 안전성

      * 모듈 수준 함수

        * "getLogger()"

        * "getLoggerClass()"

        * "getLogRecordFactory()"

        * "debug()"

        * "info()"

        * "warning()"

        * "error()"

        * "critical()"

        * "exception()"

        * "log()"

        * "disable()"

        * "addLevelName()"

        * "getLevelNamesMapping()"

        * "getLevelName()"

        * "getHandlerByName()"

        * "getHandlerNames()"

        * "makeLogRecord()"

        * "basicConfig()"

        * "shutdown()"

        * "setLoggerClass()"

        * "setLogRecordFactory()"

      * 모듈 수준 어트리뷰트

        * "lastResort"

        * "raiseExceptions"

      * warnings 모듈과의 통합

        * "captureWarnings()"

    * "logging.config" --- Logging configuration

      * 구성 함수

        * "dictConfig()"

        * "fileConfig()"

        * "listen()"

        * "stopListening()"

      * Security considerations

      * 구성 딕셔너리 스키마

        * 딕셔너리 스키마 세부사항

        * 증분 구성

        * 객체 연결

        * 사용자 정의 객체

        * Handler configuration order

        * 외부 객체에 대한 액세스

        * 내부 객체에 대한 액세스

        * 임포트 결정과 사용자 정의 임포터

        * Configuring QueueHandler and QueueListener

      * 구성 파일 형식

    * "logging.handlers" --- Logging handlers

      * StreamHandler

        * "StreamHandler"

          * "emit()"

          * "flush()"

          * "setStream()"

          * "terminator"

      * FileHandler

        * "FileHandler"

          * "close()"

          * "emit()"

      * NullHandler

        * "NullHandler"

          * "emit()"

          * "handle()"

          * "createLock()"

      * WatchedFileHandler

        * "WatchedFileHandler"

          * "reopenIfNeeded()"

          * "emit()"

      * BaseRotatingHandler

        * "BaseRotatingHandler"

          * "namer"

          * "rotator"

          * "rotation_filename()"

          * "rotate()"

      * RotatingFileHandler

        * "RotatingFileHandler"

          * "doRollover()"

          * "emit()"

      * TimedRotatingFileHandler

        * "TimedRotatingFileHandler"

          * "doRollover()"

          * "emit()"

          * "getFilesToDelete()"

      * SocketHandler

        * "SocketHandler"

          * "close()"

          * "emit()"

          * "handleError()"

          * "makeSocket()"

          * "makePickle()"

          * "send()"

          * "createSocket()"

      * DatagramHandler

        * "DatagramHandler"

          * "emit()"

          * "makeSocket()"

          * "send()"

      * SysLogHandler

        * "SysLogHandler"

          * "close()"

          * "createSocket()"

          * "emit()"

          * "encodePriority()"

          * "mapPriority()"

      * NTEventLogHandler

        * "NTEventLogHandler"

          * "close()"

          * "emit()"

          * "getEventCategory()"

          * "getEventType()"

          * "getMessageID()"

      * SMTPHandler

        * "SMTPHandler"

          * "emit()"

          * "getSubject()"

      * MemoryHandler

        * "BufferingHandler"

          * "emit()"

          * "flush()"

          * "shouldFlush()"

        * "MemoryHandler"

          * "close()"

          * "flush()"

          * "setTarget()"

          * "shouldFlush()"

      * HTTPHandler

        * "HTTPHandler"

          * "mapLogRecord()"

          * "emit()"

      * QueueHandler

        * "QueueHandler"

          * "emit()"

          * "prepare()"

          * "enqueue()"

          * "listener"

      * QueueListener

        * "QueueListener"

          * "dequeue()"

          * "prepare()"

          * "handle()"

          * "start()"

          * "stop()"

          * "enqueue_sentinel()"

    * "getpass" --- Portable password input

      * "getpass()"

      * "GetPassWarning"

      * "getuser()"

    * "curses" --- Terminal handling for character-cell displays

      * 함수

        * "error"

        * "baudrate()"

        * "beep()"

        * "can_change_color()"

        * "cbreak()"

        * "color_content()"

        * "color_pair()"

        * "curs_set()"

        * "def_prog_mode()"

        * "def_shell_mode()"

        * "delay_output()"

        * "doupdate()"

        * "echo()"

        * "endwin()"

        * "erasechar()"

        * "filter()"

        * "flash()"

        * "flushinp()"

        * "getmouse()"

        * "getsyx()"

        * "getwin()"

        * "has_colors()"

        * "has_extended_color_support()"

        * "has_ic()"

        * "has_il()"

        * "has_key()"

        * "halfdelay()"

        * "init_color()"

        * "init_pair()"

        * "initscr()"

        * "is_term_resized()"

        * "isendwin()"

        * "keyname()"

        * "killchar()"

        * "longname()"

        * "meta()"

        * "mouseinterval()"

        * "mousemask()"

        * "napms()"

        * "newpad()"

        * "newwin()"

        * "nl()"

        * "nocbreak()"

        * "noecho()"

        * "nonl()"

        * "noqiflush()"

        * "noraw()"

        * "pair_content()"

        * "pair_number()"

        * "putp()"

        * "qiflush()"

        * "raw()"

        * "reset_prog_mode()"

        * "reset_shell_mode()"

        * "resetty()"

        * "resize_term()"

        * "resizeterm()"

        * "savetty()"

        * "get_escdelay()"

        * "set_escdelay()"

        * "get_tabsize()"

        * "set_tabsize()"

        * "setsyx()"

        * "setupterm()"

        * "start_color()"

        * "termattrs()"

        * "termname()"

        * "tigetflag()"

        * "tigetnum()"

        * "tigetstr()"

        * "tparm()"

        * "typeahead()"

        * "unctrl()"

        * "ungetch()"

        * "update_lines_cols()"

        * "unget_wch()"

        * "ungetmouse()"

        * "use_env()"

        * "use_default_colors()"

        * "wrapper()"

      * 창 객체

        * "addch()"

        * "addnstr()"

        * "addstr()"

        * "attroff()"

        * "attron()"

        * "attrset()"

        * "bkgd()"

        * "bkgdset()"

        * "border()"

        * "box()"

        * "chgat()"

        * "clear()"

        * "clearok()"

        * "clrtobot()"

        * "clrtoeol()"

        * "cursyncup()"

        * "delch()"

        * "deleteln()"

        * "derwin()"

        * "echochar()"

        * "enclose()"

        * "encoding"

        * "erase()"

        * "getbegyx()"

        * "getbkgd()"

        * "getch()"

        * "get_wch()"

        * "getkey()"

        * "getmaxyx()"

        * "getparyx()"

        * "getstr()"

        * "getyx()"

        * "hline()"

        * "idcok()"

        * "idlok()"

        * "immedok()"

        * "inch()"

        * "insch()"

        * "insdelln()"

        * "insertln()"

        * "insnstr()"

        * "insstr()"

        * "instr()"

        * "is_linetouched()"

        * "is_wintouched()"

        * "keypad()"

        * "leaveok()"

        * "move()"

        * "mvderwin()"

        * "mvwin()"

        * "nodelay()"

        * "notimeout()"

        * "noutrefresh()"

        * "overlay()"

        * "overwrite()"

        * "putwin()"

        * "redrawln()"

        * "redrawwin()"

        * "refresh()"

        * "resize()"

        * "scroll()"

        * "scrollok()"

        * "setscrreg()"

        * "standend()"

        * "standout()"

        * "subpad()"

        * "subwin()"

        * "syncdown()"

        * "syncok()"

        * "syncup()"

        * "timeout()"

        * "touchline()"

        * "touchwin()"

        * "untouchwin()"

        * "vline()"

      * 상수

        * "ERR"

        * "OK"

        * "version"

        * "__version__"

        * "ncurses_version"

        * "COLORS"

        * "COLOR_PAIRS"

        * "COLS"

        * "LINES"

        * "A_ALTCHARSET"

        * "A_BLINK"

        * "A_BOLD"

        * "A_DIM"

        * "A_INVIS"

        * "A_ITALIC"

        * "A_NORMAL"

        * "A_PROTECT"

        * "A_REVERSE"

        * "A_STANDOUT"

        * "A_UNDERLINE"

        * "A_HORIZONTAL"

        * "A_LEFT"

        * "A_LOW"

        * "A_RIGHT"

        * "A_TOP"

        * "A_VERTICAL"

        * "A_ATTRIBUTES"

        * "A_CHARTEXT"

        * "A_COLOR"

        * "KEY_MIN"

        * "KEY_BREAK"

        * "KEY_DOWN"

        * "KEY_UP"

        * "KEY_LEFT"

        * "KEY_RIGHT"

        * "KEY_HOME"

        * "KEY_BACKSPACE"

        * "KEY_F0"

        * "KEY_Fn"

        * "KEY_DL"

        * "KEY_IL"

        * "KEY_DC"

        * "KEY_IC"

        * "KEY_EIC"

        * "KEY_CLEAR"

        * "KEY_EOS"

        * "KEY_EOL"

        * "KEY_SF"

        * "KEY_SR"

        * "KEY_NPAGE"

        * "KEY_PPAGE"

        * "KEY_STAB"

        * "KEY_CTAB"

        * "KEY_CATAB"

        * "KEY_ENTER"

        * "KEY_SRESET"

        * "KEY_RESET"

        * "KEY_PRINT"

        * "KEY_LL"

        * "KEY_A1"

        * "KEY_A3"

        * "KEY_B2"

        * "KEY_C1"

        * "KEY_C3"

        * "KEY_BTAB"

        * "KEY_BEG"

        * "KEY_CANCEL"

        * "KEY_CLOSE"

        * "KEY_COMMAND"

        * "KEY_COPY"

        * "KEY_CREATE"

        * "KEY_END"

        * "KEY_EXIT"

        * "KEY_FIND"

        * "KEY_HELP"

        * "KEY_MARK"

        * "KEY_MESSAGE"

        * "KEY_MOVE"

        * "KEY_NEXT"

        * "KEY_OPEN"

        * "KEY_OPTIONS"

        * "KEY_PREVIOUS"

        * "KEY_REDO"

        * "KEY_REFERENCE"

        * "KEY_REFRESH"

        * "KEY_REPLACE"

        * "KEY_RESTART"

        * "KEY_RESUME"

        * "KEY_SAVE"

        * "KEY_SBEG"

        * "KEY_SCANCEL"

        * "KEY_SCOMMAND"

        * "KEY_SCOPY"

        * "KEY_SCREATE"

        * "KEY_SDC"

        * "KEY_SDL"

        * "KEY_SELECT"

        * "KEY_SEND"

        * "KEY_SEOL"

        * "KEY_SEXIT"

        * "KEY_SFIND"

        * "KEY_SHELP"

        * "KEY_SHOME"

        * "KEY_SIC"

        * "KEY_SLEFT"

        * "KEY_SMESSAGE"

        * "KEY_SMOVE"

        * "KEY_SNEXT"

        * "KEY_SOPTIONS"

        * "KEY_SPREVIOUS"

        * "KEY_SPRINT"

        * "KEY_SREDO"

        * "KEY_SREPLACE"

        * "KEY_SRIGHT"

        * "KEY_SRSUME"

        * "KEY_SSAVE"

        * "KEY_SSUSPEND"

        * "KEY_SUNDO"

        * "KEY_SUSPEND"

        * "KEY_UNDO"

        * "KEY_MOUSE"

        * "KEY_RESIZE"

        * "KEY_MAX"

        * "ACS_BBSS"

        * "ACS_BLOCK"

        * "ACS_BOARD"

        * "ACS_BSBS"

        * "ACS_BSSB"

        * "ACS_BSSS"

        * "ACS_BTEE"

        * "ACS_BULLET"

        * "ACS_CKBOARD"

        * "ACS_DARROW"

        * "ACS_DEGREE"

        * "ACS_DIAMOND"

        * "ACS_GEQUAL"

        * "ACS_HLINE"

        * "ACS_LANTERN"

        * "ACS_LARROW"

        * "ACS_LEQUAL"

        * "ACS_LLCORNER"

        * "ACS_LRCORNER"

        * "ACS_LTEE"

        * "ACS_NEQUAL"

        * "ACS_PI"

        * "ACS_PLMINUS"

        * "ACS_PLUS"

        * "ACS_RARROW"

        * "ACS_RTEE"

        * "ACS_S1"

        * "ACS_S3"

        * "ACS_S7"

        * "ACS_S9"

        * "ACS_SBBS"

        * "ACS_SBSB"

        * "ACS_SBSS"

        * "ACS_SSBB"

        * "ACS_SSBS"

        * "ACS_SSSB"

        * "ACS_SSSS"

        * "ACS_STERLING"

        * "ACS_TTEE"

        * "ACS_UARROW"

        * "ACS_ULCORNER"

        * "ACS_URCORNER"

        * "ACS_VLINE"

        * "BUTTONn_PRESSED"

        * "BUTTONn_RELEASED"

        * "BUTTONn_CLICKED"

        * "BUTTONn_DOUBLE_CLICKED"

        * "BUTTONn_TRIPLE_CLICKED"

        * "BUTTON_SHIFT"

        * "BUTTON_CTRL"

        * "BUTTON_ALT"

        * "COLOR_BLACK"

        * "COLOR_BLUE"

        * "COLOR_CYAN"

        * "COLOR_GREEN"

        * "COLOR_MAGENTA"

        * "COLOR_RED"

        * "COLOR_WHITE"

        * "COLOR_YELLOW"

    * "curses.textpad" --- curses 프로그램을 위한 텍스트 입력 위젯

      * "rectangle()"

      * Textbox 객체

        * "Textbox"

          * "edit()"

          * "do_command()"

          * "gather()"

          * "stripspaces"

    * "curses.ascii" --- Utilities for ASCII characters

      * "NUL"

      * "SOH"

      * "STX"

      * "ETX"

      * "EOT"

      * "ENQ"

      * "ACK"

      * "BEL"

      * "BS"

      * "TAB"

      * "HT"

      * "LF"

      * "NL"

      * "VT"

      * "FF"

      * "CR"

      * "SO"

      * "SI"

      * "DLE"

      * "DC1"

      * "DC2"

      * "DC3"

      * "DC4"

      * "NAK"

      * "SYN"

      * "ETB"

      * "CAN"

      * "EM"

      * "SUB"

      * "ESC"

      * "FS"

      * "GS"

      * "RS"

      * "US"

      * "SP"

      * "DEL"

      * "isalnum()"

      * "isalpha()"

      * "isascii()"

      * "isblank()"

      * "iscntrl()"

      * "isdigit()"

      * "isgraph()"

      * "islower()"

      * "isprint()"

      * "ispunct()"

      * "isspace()"

      * "isupper()"

      * "isxdigit()"

      * "isctrl()"

      * "ismeta()"

      * "ascii()"

      * "ctrl()"

      * "alt()"

      * "unctrl()"

      * "controlnames"

    * "curses.panel" --- A panel stack extension for curses

      * 함수

        * "bottom_panel()"

        * "new_panel()"

        * "top_panel()"

        * "update_panels()"

      * Panel 객체

        * "above()"

        * "below()"

        * "bottom()"

        * "hidden()"

        * "hide()"

        * "move()"

        * "replace()"

        * "set_userptr()"

        * "show()"

        * "top()"

        * "userptr()"

        * "window()"

    * "platform" ---  Access to underlying platform's identifying data

      * 크로스 플랫폼

        * "architecture()"

        * "machine()"

        * "node()"

        * "platform()"

        * "processor()"

        * "python_build()"

        * "python_compiler()"

        * "python_branch()"

        * "python_implementation()"

        * "python_revision()"

        * "python_version()"

        * "python_version_tuple()"

        * "release()"

        * "system()"

        * "system_alias()"

        * "version()"

        * "uname()"

      * 자바 플랫폼

        * "java_ver()"

      * 윈도우 플랫폼

        * "win32_ver()"

        * "win32_edition()"

        * "win32_is_iot()"

      * macOS Platform

        * "mac_ver()"

      * 유닉스 플랫폼

        * "libc_ver()"

      * Linux Platforms

        * "freedesktop_os_release()"

    * "errno" --- Standard errno system symbols

      * "errorcode"

      * "EPERM"

      * "ENOENT"

      * "ESRCH"

      * "EINTR"

      * "EIO"

      * "ENXIO"

      * "E2BIG"

      * "ENOEXEC"

      * "EBADF"

      * "ECHILD"

      * "EAGAIN"

      * "ENOMEM"

      * "EACCES"

      * "EFAULT"

      * "ENOTBLK"

      * "EBUSY"

      * "EEXIST"

      * "EXDEV"

      * "ENODEV"

      * "ENOTDIR"

      * "EISDIR"

      * "EINVAL"

      * "ENFILE"

      * "EMFILE"

      * "ENOTTY"

      * "ETXTBSY"

      * "EFBIG"

      * "ENOSPC"

      * "ESPIPE"

      * "EROFS"

      * "EMLINK"

      * "EPIPE"

      * "EDOM"

      * "ERANGE"

      * "EDEADLK"

      * "ENAMETOOLONG"

      * "ENOLCK"

      * "ENOSYS"

      * "ENOTEMPTY"

      * "ELOOP"

      * "EWOULDBLOCK"

      * "ENOMSG"

      * "EIDRM"

      * "ECHRNG"

      * "EL2NSYNC"

      * "EL3HLT"

      * "EL3RST"

      * "ELNRNG"

      * "EUNATCH"

      * "ENOCSI"

      * "EL2HLT"

      * "EBADE"

      * "EBADR"

      * "EXFULL"

      * "ENOANO"

      * "EBADRQC"

      * "EBADSLT"

      * "EDEADLOCK"

      * "EBFONT"

      * "ENOSTR"

      * "ENODATA"

      * "ETIME"

      * "ENOSR"

      * "ENONET"

      * "ENOPKG"

      * "EREMOTE"

      * "ENOLINK"

      * "EADV"

      * "ESRMNT"

      * "ECOMM"

      * "EPROTO"

      * "EMULTIHOP"

      * "EDOTDOT"

      * "EBADMSG"

      * "EOVERFLOW"

      * "ENOTUNIQ"

      * "EBADFD"

      * "EREMCHG"

      * "ELIBACC"

      * "ELIBBAD"

      * "ELIBSCN"

      * "ELIBMAX"

      * "ELIBEXEC"

      * "EILSEQ"

      * "ERESTART"

      * "ESTRPIPE"

      * "EUSERS"

      * "ENOTSOCK"

      * "EDESTADDRREQ"

      * "EMSGSIZE"

      * "EPROTOTYPE"

      * "ENOPROTOOPT"

      * "EPROTONOSUPPORT"

      * "ESOCKTNOSUPPORT"

      * "EOPNOTSUPP"

      * "ENOTSUP"

      * "EPFNOSUPPORT"

      * "EAFNOSUPPORT"

      * "EADDRINUSE"

      * "EADDRNOTAVAIL"

      * "ENETDOWN"

      * "ENETUNREACH"

      * "ENETRESET"

      * "ECONNABORTED"

      * "ECONNRESET"

      * "ENOBUFS"

      * "EISCONN"

      * "ENOTCONN"

      * "ESHUTDOWN"

      * "ETOOMANYREFS"

      * "ETIMEDOUT"

      * "ECONNREFUSED"

      * "EHOSTDOWN"

      * "EHOSTUNREACH"

      * "EALREADY"

      * "EINPROGRESS"

      * "ESTALE"

      * "EUCLEAN"

      * "ENOTNAM"

      * "ENAVAIL"

      * "EISNAM"

      * "EREMOTEIO"

      * "EDQUOT"

      * "EQFULL"

      * "ENOTCAPABLE"

      * "ECANCELED"

      * "EOWNERDEAD"

      * "ENOTRECOVERABLE"

    * "ctypes" --- A foreign function library for Python

      * ctypes 자습서

        * 동적 링크 라이브러리 로드하기

        * 로드된 dll에서 함수에 액세스하기

        * 함수 호출하기

        * 기본 데이터형

        * 함수 호출하기, 계속

        * Calling variadic functions

        * 사용자 정의 데이터형을 사용하여 함수 호출하기

        * 필수 인자 형 (함수 프로토타입) 지정하기

        * 반환형

        * 포인터 전달하기 (또는: 참조로 매개 변수 전달하기)

        * 구조체와 공용체

        * 구조체/공용체 정렬과 바이트 순서

        * 구조체와 공용체의 비트 필드

        * 배열

        * 포인터

        * 형 변환

        * 불완전한 형

        * 콜백 함수

        * dll에서 내 보낸 값을 액세스하기

        * 의외의 것들

        * 가변 크기 데이터형

      * ctypes 레퍼런스

        * 공유 라이브러리 찾기

        * 공유 라이브러리 로드하기

          * "CDLL"

          * "OleDLL"

          * "WinDLL"

          * "PyDLL"

          * "_handle"

          * "_name"

          * "LibraryLoader"

            * "LoadLibrary()"

        * 외부 함수

          * "_CFuncPtr"

            * "restype"

            * "argtypes"

            * "errcheck"

          * "ArgumentError"

        * 함수 프로토타입

          * "CFUNCTYPE()"

          * "WINFUNCTYPE()"

          * "PYFUNCTYPE()"

        * 유틸리티 함수

          * "addressof()"

          * "alignment()"

          * "byref()"

          * "cast()"

          * "create_string_buffer()"

          * "create_unicode_buffer()"

          * "DllCanUnloadNow()"

          * "DllGetClassObject()"

          * "find_library()"

          * "find_msvcrt()"

          * "FormatError()"

          * "GetLastError()"

          * "get_errno()"

          * "get_last_error()"

          * "memmove()"

          * "memset()"

          * "POINTER()"

          * "pointer()"

          * "resize()"

          * "set_errno()"

          * "set_last_error()"

          * "sizeof()"

          * "string_at()"

          * "WinError()"

          * "wstring_at()"

        * 데이터형

          * "_CData"

            * "from_buffer()"

            * "from_buffer_copy()"

            * "from_address()"

            * "from_param()"

            * "in_dll()"

            * "_b_base_"

            * "_b_needsfree_"

            * "_objects"

        * 기본 데이터형

          * "_SimpleCData"

            * "value"

          * "c_byte"

          * "c_char"

          * "c_char_p"

          * "c_double"

          * "c_longdouble"

          * "c_float"

          * "c_int"

          * "c_int8"

          * "c_int16"

          * "c_int32"

          * "c_int64"

          * "c_long"

          * "c_longlong"

          * "c_short"

          * "c_size_t"

          * "c_ssize_t"

          * "c_time_t"

          * "c_ubyte"

          * "c_uint"

          * "c_uint8"

          * "c_uint16"

          * "c_uint32"

          * "c_uint64"

          * "c_ulong"

          * "c_ulonglong"

          * "c_ushort"

          * "c_void_p"

          * "c_wchar"

          * "c_wchar_p"

          * "c_bool"

          * "HRESULT"

          * "py_object"

        * 구조화된 데이터형

          * "Union"

          * "BigEndianUnion"

          * "LittleEndianUnion"

          * "BigEndianStructure"

          * "LittleEndianStructure"

          * "Structure"

            * "_fields_"

            * "_pack_"

            * "_anonymous_"

        * 배열과 포인터

          * "Array"

            * "_length_"

            * "_type_"

          * "_Pointer"

            * "_type_"

            * "contents"

  * 동시 실행

    * "threading" --- Thread-based parallelism

      * "active_count()"

      * "current_thread()"

      * "excepthook()"

      * "__excepthook__"

      * "get_ident()"

      * "get_native_id()"

      * "enumerate()"

      * "main_thread()"

      * "settrace()"

      * "settrace_all_threads()"

      * "gettrace()"

      * "setprofile()"

      * "setprofile_all_threads()"

      * "getprofile()"

      * "stack_size()"

      * "TIMEOUT_MAX"

      * 스레드 로컬 데이터

        * "local"

      * Thread 객체

        * "Thread"

          * "start()"

          * "run()"

          * "join()"

          * "name"

          * "getName()"

          * "setName()"

          * "ident"

          * "native_id"

          * "is_alive()"

          * "daemon"

          * "isDaemon()"

          * "setDaemon()"

      * Lock 객체

        * "Lock"

          * "acquire()"

          * "release()"

          * "locked()"

      * RLock 객체

        * "RLock"

          * "acquire()"

          * "release()"

      * Condition 객체

        * "Condition"

          * "acquire()"

          * "release()"

          * "wait()"

          * "wait_for()"

          * "notify()"

          * "notify_all()"

      * Semaphore 객체

        * "Semaphore"

          * "acquire()"

          * "release()"

        * "BoundedSemaphore"

        * "Semaphore" 예

      * Event 객체

        * "Event"

          * "is_set()"

          * "set()"

          * "clear()"

          * "wait()"

      * Timer 객체

        * "Timer"

          * "cancel()"

      * Barrier 객체

        * "Barrier"

          * "wait()"

          * "reset()"

          * "abort()"

          * "parties"

          * "n_waiting"

          * "broken"

        * "BrokenBarrierError"

      * "with" 문으로 록, 조건 및 세마포어 사용하기

    * "multiprocessing" --- Process-based parallelism

      * 소개

        * "Process" 클래스

        * 컨텍스트 및 시작 방법

        * 프로세스 간 객체 교환

        * 프로세스 간 동기화

        * 프로세스 간 상태 공유

        * 작업자 풀 사용

      * 레퍼런스

        * "Process"와 예외

          * "Process"

            * "run()"

            * "start()"

            * "join()"

            * "name"

            * "is_alive()"

            * "daemon"

            * "pid"

            * "exitcode"

            * "authkey"

            * "sentinel"

            * "terminate()"

            * "kill()"

            * "close()"

          * "ProcessError"

          * "BufferTooShort"

          * "AuthenticationError"

          * "TimeoutError"

        * 파이프와 큐

          * "Pipe()"

          * "Queue"

            * "qsize()"

            * "empty()"

            * "full()"

            * "put()"

            * "put_nowait()"

            * "get()"

            * "get_nowait()"

            * "close()"

            * "join_thread()"

            * "cancel_join_thread()"

          * "SimpleQueue"

            * "close()"

            * "empty()"

            * "get()"

            * "put()"

          * "JoinableQueue"

            * "task_done()"

            * "join()"

        * 잡동사니

          * "active_children()"

          * "cpu_count()"

          * "current_process()"

          * "parent_process()"

          * "freeze_support()"

          * "get_all_start_methods()"

          * "get_context()"

          * "get_start_method()"

          * "set_executable()"

          * "set_forkserver_preload()"

          * "set_start_method()"

        * Connection 객체

          * "Connection"

            * "send()"

            * "recv()"

            * "fileno()"

            * "close()"

            * "poll()"

            * "send_bytes()"

            * "recv_bytes()"

            * "recv_bytes_into()"

        * 동기화 프리미티브

          * "Barrier"

          * "BoundedSemaphore"

          * "Condition"

          * "Event"

          * "Lock"

            * "acquire()"

            * "release()"

          * "RLock"

            * "acquire()"

            * "release()"

          * "Semaphore"

        * 공유 "ctypes" 객체

          * "Value()"

          * "Array()"

          * "multiprocessing.sharedctypes" 모듈

            * "RawArray()"

            * "RawValue()"

            * "Array()"

            * "Value()"

            * "copy()"

            * "synchronized()"

        * 관리자

          * "Manager()"

          * "BaseManager"

            * "start()"

            * "get_server()"

            * "connect()"

            * "shutdown()"

            * "register()"

            * "address"

          * "SyncManager"

            * "Barrier()"

            * "BoundedSemaphore()"

            * "Condition()"

            * "Event()"

            * "Lock()"

            * "Namespace()"

            * "Queue()"

            * "RLock()"

            * "Semaphore()"

            * "Array()"

            * "Value()"

            * "dict()"

            * "list()"

          * "Namespace"

          * 사용자 정의 관리자

          * 원격 관리자 사용하기

        * 프락시 객체

          * "BaseProxy"

            * "_callmethod()"

            * "_getvalue()"

            * "__repr__()"

            * "__str__()"

          * 정리

        * 프로세스 풀

          * "Pool"

            * "apply()"

            * "apply_async()"

            * "map()"

            * "map_async()"

            * "imap()"

            * "imap_unordered()"

            * "starmap()"

            * "starmap_async()"

            * "close()"

            * "terminate()"

            * "join()"

          * "AsyncResult"

            * "get()"

            * "wait()"

            * "ready()"

            * "successful()"

        * 리스너와 클라이언트

          * "deliver_challenge()"

          * "answer_challenge()"

          * "Client()"

          * "Listener"

            * "accept()"

            * "close()"

            * "address"

            * "last_accepted"

          * "wait()"

          * 주소 형식

        * 인증 키

        * 로깅

          * "get_logger()"

          * "log_to_stderr()"

        * "multiprocessing.dummy" 모듈

          * "ThreadPool"

      * 프로그래밍 지침

        * 모든 시작 방법

        * *spawn* 과 *forkserver* 시작 방법

      * 예제

    * "multiprocessing.shared_memory" --- Shared memory for direct
      access across processes

      * "SharedMemory"

        * "close()"

        * "unlink()"

        * "buf"

        * "name"

        * "size"

      * "SharedMemoryManager"

        * "SharedMemory()"

        * "ShareableList()"

      * "ShareableList"

        * "count()"

        * "index()"

        * "format"

        * "shm"

    * The "concurrent" package

    * "concurrent.futures" --- Launching parallel tasks

      * Executor 객체

        * "Executor"

          * "submit()"

          * "map()"

          * "shutdown()"

      * ThreadPoolExecutor

        * "ThreadPoolExecutor"

        * ThreadPoolExecutor 예제

      * ProcessPoolExecutor

        * "ProcessPoolExecutor"

        * ProcessPoolExecutor 예제

      * Future 객체

        * "Future"

          * "cancel()"

          * "cancelled()"

          * "running()"

          * "done()"

          * "result()"

          * "exception()"

          * "add_done_callback()"

          * "set_running_or_notify_cancel()"

          * "set_result()"

          * "set_exception()"

      * 모듈 함수

        * "wait()"

          * "FIRST_COMPLETED"

          * "FIRST_EXCEPTION"

          * "ALL_COMPLETED"

        * "as_completed()"

      * 예외 클래스

        * "CancelledError"

        * "TimeoutError"

        * "BrokenExecutor"

        * "InvalidStateError"

        * "BrokenThreadPool"

        * "BrokenProcessPool"

    * "subprocess" --- Subprocess management

      * "subprocess" 모듈 사용하기

        * "run()"

        * "CompletedProcess"

          * "args"

          * "returncode"

          * "stdout"

          * "stderr"

          * "check_returncode()"

        * "DEVNULL"

        * "PIPE"

        * "STDOUT"

        * "SubprocessError"

        * "TimeoutExpired"

          * "cmd"

          * "timeout"

          * "output"

          * "stdout"

          * "stderr"

        * "CalledProcessError"

          * "returncode"

          * "cmd"

          * "output"

          * "stdout"

          * "stderr"

        * 자주 사용되는 인자

        * Popen 생성자

          * "Popen"

        * 예외

      * 보안 고려 사항

      * Popen 객체

        * "poll()"

        * "wait()"

        * "communicate()"

        * "send_signal()"

        * "terminate()"

        * "kill()"

        * "args"

        * "stdin"

        * "stdout"

        * "stderr"

        * "pid"

        * "returncode"

      * 윈도우 Popen 도우미

        * "STARTUPINFO"

          * "dwFlags"

          * "hStdInput"

          * "hStdOutput"

          * "hStdError"

          * "wShowWindow"

          * "lpAttributeList"

        * 윈도우 상수

          * "STD_INPUT_HANDLE"

          * "STD_OUTPUT_HANDLE"

          * "STD_ERROR_HANDLE"

          * "SW_HIDE"

          * "STARTF_USESTDHANDLES"

          * "STARTF_USESHOWWINDOW"

          * "CREATE_NEW_CONSOLE"

          * "CREATE_NEW_PROCESS_GROUP"

          * "ABOVE_NORMAL_PRIORITY_CLASS"

          * "BELOW_NORMAL_PRIORITY_CLASS"

          * "HIGH_PRIORITY_CLASS"

          * "IDLE_PRIORITY_CLASS"

          * "NORMAL_PRIORITY_CLASS"

          * "REALTIME_PRIORITY_CLASS"

          * "CREATE_NO_WINDOW"

          * "DETACHED_PROCESS"

          * "CREATE_DEFAULT_ERROR_MODE"

          * "CREATE_BREAKAWAY_FROM_JOB"

      * 오래된 고수준 API

        * "call()"

        * "check_call()"

        * "check_output()"

      * 이전 함수를 "subprocess" 모듈로 교체하기

        * **/bin/sh** 셸 명령 치환 교체하기

        * 셸 파이프라인 교체하기

        * "os.system()" 교체하기

        * "os.spawn" 패밀리 교체하기

        * "os.popen()", "os.popen2()", "os.popen3()" 교체하기

        * Replacing functions from the "popen2" module

      * 레거시 셸 호출 함수

        * "getstatusoutput()"

        * "getoutput()"

      * 노트

        * 윈도우에서 인자 시퀀스를 문자열로 변환하기

        * Disabling use of "vfork()" or "posix_spawn()"

    * "sched" --- Event scheduler

      * "scheduler"

      * 스케줄러 객체

        * "enterabs()"

        * "enter()"

        * "cancel()"

        * "empty()"

        * "run()"

        * "queue"

    * "queue" --- A synchronized queue class

      * "Queue"

      * "LifoQueue"

      * "PriorityQueue"

      * "SimpleQueue"

      * "Empty"

      * "Full"

      * 큐 객체

        * "qsize()"

        * "empty()"

        * "full()"

        * "put()"

        * "put_nowait()"

        * "get()"

        * "get_nowait()"

        * "task_done()"

        * "join()"

      * SimpleQueue 객체

        * "qsize()"

        * "empty()"

        * "put()"

        * "put_nowait()"

        * "get()"

        * "get_nowait()"

    * "contextvars" --- Context Variables

      * 컨텍스트 변수

        * "ContextVar"

          * "name"

          * "get()"

          * "set()"

          * "reset()"

        * "Token"

          * "var"

          * "old_value"

          * "MISSING"

      * 수동 컨텍스트 관리

        * "copy_context()"

        * "Context"

          * "run()"

          * "copy()"

          * "get()"

          * "keys()"

          * "values()"

          * "items()"

      * asyncio 지원

    * "_thread" --- Low-level threading API

      * "error"

      * "LockType"

      * "start_new_thread()"

      * "interrupt_main()"

      * "exit()"

      * "allocate_lock()"

      * "get_ident()"

      * "get_native_id()"

      * "stack_size()"

      * "TIMEOUT_MAX"

      * "acquire()"

      * "release()"

      * "locked()"

  * 네트워킹과 프로세스 간 통신

    * "asyncio" --- Asynchronous I/O

      * Runners

        * Running an asyncio Program

          * "run()"

        * Runner context manager

          * "Runner"

            * "run()"

            * "close()"

            * "get_loop()"

        * Handling Keyboard Interruption

      * 코루틴과 태스크

        * 코루틴

        * 어웨이터블

        * 태스크 만들기

          * "create_task()"

        * Task Cancellation

        * Task Groups

          * "TaskGroup"

            * "create_task()"

          * Terminating a Task Group

        * 잠자기

          * "sleep()"

        * 동시에 태스크 실행하기

          * "gather()"

        * Eager Task Factory

          * "eager_task_factory()"

          * "create_eager_task_factory()"

        * 취소로부터 보호하기

          * "shield()"

        * 시간제한

          * "timeout()"

            * "Timeout"

              * "when()"

              * "reschedule()"

              * "expired()"

          * "timeout_at()"

          * "wait_for()"

        * 대기 프리미티브

          * "wait()"

            * "FIRST_COMPLETED"

            * "FIRST_EXCEPTION"

            * "ALL_COMPLETED"

          * "as_completed()"

        * 스레드에서 실행하기

          * "to_thread()"

        * 다른 스레드에서 예약하기

          * "run_coroutine_threadsafe()"

        * 인트로스펙션

          * "current_task()"

          * "all_tasks()"

          * "iscoroutine()"

        * Task 객체

          * "Task"

            * "done()"

            * "result()"

            * "exception()"

            * "add_done_callback()"

            * "remove_done_callback()"

            * "get_stack()"

            * "print_stack()"

            * "get_coro()"

            * "get_context()"

            * "get_name()"

            * "set_name()"

            * "cancel()"

            * "cancelled()"

            * "uncancel()"

            * "cancelling()"

      * 스트림

        * "open_connection()"

        * "start_server()"

        * "open_unix_connection()"

        * "start_unix_server()"

        * StreamReader

          * "StreamReader"

            * "feed_eof()"

            * "read()"

            * "readline()"

            * "readexactly()"

            * "readuntil()"

            * "at_eof()"

        * StreamWriter

          * "StreamWriter"

            * "write()"

            * "writelines()"

            * "close()"

            * "can_write_eof()"

            * "write_eof()"

            * "transport"

            * "get_extra_info()"

            * "drain()"

            * "start_tls()"

            * "is_closing()"

            * "wait_closed()"

        * 예제

          * 스트림을 사용하는 TCP 메아리 클라이언트

          * 스트림을 사용하는 TCP 메아리 서버

          * HTTP 헤더 가져오기

          * 스트림을 사용하여 데이터를 기다리는 열린 소켓 등록

      * 동기화 프리미티브

        * Lock

          * "Lock"

            * "acquire()"

            * "release()"

            * "locked()"

        * Event

          * "Event"

            * "wait()"

            * "set()"

            * "clear()"

            * "is_set()"

        * Condition

          * "Condition"

            * "acquire()"

            * "notify()"

            * "locked()"

            * "notify_all()"

            * "release()"

            * "wait()"

            * "wait_for()"

        * Semaphore

          * "Semaphore"

            * "acquire()"

            * "locked()"

            * "release()"

        * BoundedSemaphore

          * "BoundedSemaphore"

        * Barrier

          * "Barrier"

            * "wait()"

            * "reset()"

            * "abort()"

            * "parties"

            * "n_waiting"

            * "broken"

          * "BrokenBarrierError"

      * 서브 프로세스

        * 서브 프로세스 만들기

          * "create_subprocess_exec()"

          * "create_subprocess_shell()"

        * 상수

          * "PIPE"

          * "STDOUT"

          * "DEVNULL"

        * 서브 프로세스와 상호 작용하기

          * "Process"

            * "wait()"

            * "communicate()"

            * "send_signal()"

            * "terminate()"

            * "kill()"

            * "stdin"

            * "stdout"

            * "stderr"

            * "pid"

            * "returncode"

          * 서브 프로세스와 스레드

          * 예제

      * 큐

        * Queue

          * "Queue"

            * "maxsize"

            * "empty()"

            * "full()"

            * "get()"

            * "get_nowait()"

            * "join()"

            * "put()"

            * "put_nowait()"

            * "qsize()"

            * "task_done()"

        * 우선순위 큐

          * "PriorityQueue"

        * LIFO 큐

          * "LifoQueue"

        * 예외

          * "QueueEmpty"

          * "QueueFull"

        * 예제

      * 예외

        * "TimeoutError"

        * "CancelledError"

        * "InvalidStateError"

        * "SendfileNotAvailableError"

        * "IncompleteReadError"

          * "expected"

          * "partial"

        * "LimitOverrunError"

          * "consumed"

      * 이벤트 루프

        * "get_running_loop()"

        * "get_event_loop()"

        * "set_event_loop()"

        * "new_event_loop()"

        * 이벤트 루프 메서드

          * 루프 실행 및 중지

            * "run_until_complete()"

            * "run_forever()"

            * "stop()"

            * "is_running()"

            * "is_closed()"

            * "close()"

            * "shutdown_asyncgens()"

            * "shutdown_default_executor()"

          * 콜백 예약하기

            * "call_soon()"

            * "call_soon_threadsafe()"

          * 지연된 콜백 예약

            * "call_later()"

            * "call_at()"

            * "time()"

          * 퓨처와 태스크 만들기

            * "create_future()"

            * "create_task()"

            * "set_task_factory()"

            * "get_task_factory()"

          * 네트워크 연결 열기

            * "create_connection()"

            * "create_datagram_endpoint()"

            * "create_unix_connection()"

          * 네트워크 서버 만들기

            * "create_server()"

            * "create_unix_server()"

            * "connect_accepted_socket()"

          * 파일 전송

            * "sendfile()"

          * TLS 업그레이드

            * "start_tls()"

          * 파일 기술자 관찰하기

            * "add_reader()"

            * "remove_reader()"

            * "add_writer()"

            * "remove_writer()"

          * 소켓 객체로 직접 작업하기

            * "sock_recv()"

            * "sock_recv_into()"

            * "sock_recvfrom()"

            * "sock_recvfrom_into()"

            * "sock_sendall()"

            * "sock_sendto()"

            * "sock_connect()"

            * "sock_accept()"

            * "sock_sendfile()"

          * DNS

            * "getaddrinfo()"

            * "getnameinfo()"

          * 파이프로 작업하기

            * "connect_read_pipe()"

            * "connect_write_pipe()"

          * 유닉스 시그널

            * "add_signal_handler()"

            * "remove_signal_handler()"

          * 스레드 또는 프로세스 풀에서 코드를 실행하기

            * "run_in_executor()"

            * "set_default_executor()"

          * 에러 처리 API

            * "set_exception_handler()"

            * "get_exception_handler()"

            * "default_exception_handler()"

            * "call_exception_handler()"

          * 디버그 모드 활성화

            * "get_debug()"

            * "set_debug()"

            * "slow_callback_duration"

          * 자식 프로세스 실행하기

            * "subprocess_exec()"

            * "subprocess_shell()"

        * 콜백 핸들

          * "Handle"

            * "get_context()"

            * "cancel()"

            * "cancelled()"

          * "TimerHandle"

            * "when()"

        * 서버 객체

          * "Server"

            * "close()"

            * "get_loop()"

            * "start_serving()"

            * "serve_forever()"

            * "is_serving()"

            * "wait_closed()"

            * "sockets"

        * 이벤트 루프 구현

          * "SelectorEventLoop"

          * "ProactorEventLoop"

          * "AbstractEventLoop"

        * 예제

          * call_soon()을 사용하는 Hello World

          * call_later()로 현재 날짜를 표시합니다.

          * 파일 기술자에서 읽기 이벤트를 관찰하기

          * SIGINT 및 SIGTERM에 대한 시그널 처리기 설정

      * 퓨처

        * 퓨처 함수

          * "isfuture()"

          * "ensure_future()"

          * "wrap_future()"

        * Future 객체

          * "Future"

            * "result()"

            * "set_result()"

            * "set_exception()"

            * "done()"

            * "cancelled()"

            * "add_done_callback()"

            * "remove_done_callback()"

            * "cancel()"

            * "exception()"

            * "get_loop()"

      * 트랜스포트와 프로토콜

        * 트랜스포트

          * 트랜스포트 계층 구조

            * "BaseTransport"

            * "WriteTransport"

            * "ReadTransport"

            * "Transport"

            * "DatagramTransport"

            * "SubprocessTransport"

          * 베이스 트랜스포트

            * "close()"

            * "is_closing()"

            * "get_extra_info()"

            * "set_protocol()"

            * "get_protocol()"

          * 읽기 전용 트랜스포트

            * "is_reading()"

            * "pause_reading()"

            * "resume_reading()"

          * 쓰기 전용 트랜스포트

            * "abort()"

            * "can_write_eof()"

            * "get_write_buffer_size()"

            * "get_write_buffer_limits()"

            * "set_write_buffer_limits()"

            * "write()"

            * "writelines()"

            * "write_eof()"

          * 데이터 그램 트랜스포트

            * "sendto()"

            * "abort()"

          * 서브 프로세스 트랜스포트

            * "get_pid()"

            * "get_pipe_transport()"

            * "get_returncode()"

            * "kill()"

            * "send_signal()"

            * "terminate()"

            * "close()"

        * 프로토콜

          * 베이스 프로토콜

            * "BaseProtocol"

            * "Protocol"

            * "BufferedProtocol"

            * "DatagramProtocol"

            * "SubprocessProtocol"

          * 베이스 프로토콜

            * "connection_made()"

            * "connection_lost()"

            * "pause_writing()"

            * "resume_writing()"

          * 스트리밍 프로토콜

            * "data_received()"

            * "eof_received()"

          * 버퍼 된 스트리밍 프로토콜

            * "get_buffer()"

            * "buffer_updated()"

            * "eof_received()"

          * 데이터 그램 프로토콜

            * "datagram_received()"

            * "error_received()"

          * 서브 프로세스 프로토콜

            * "pipe_data_received()"

            * "pipe_connection_lost()"

            * "process_exited()"

        * 예제

          * TCP 메아리 서버

          * TCP 메아리 클라이언트

          * UDP 메아리 서버

          * UDP 메아리 클라이언트

          * 기존 소켓 연결하기

          * loop.subprocess_exec() 와 SubprocessProtocol

      * 정책

        * 정책을 얻고 설정하기

          * "get_event_loop_policy()"

          * "set_event_loop_policy()"

        * 정책 객체

          * "AbstractEventLoopPolicy"

            * "get_event_loop()"

            * "set_event_loop()"

            * "new_event_loop()"

            * "get_child_watcher()"

            * "set_child_watcher()"

          * "DefaultEventLoopPolicy"

          * "WindowsSelectorEventLoopPolicy"

          * "WindowsProactorEventLoopPolicy"

        * 프로세스 감시자

          * "get_child_watcher()"

          * "set_child_watcher()"

          * "AbstractChildWatcher"

            * "add_child_handler()"

            * "remove_child_handler()"

            * "attach_loop()"

            * "is_active()"

            * "close()"

          * "ThreadedChildWatcher"

          * "MultiLoopChildWatcher"

          * "SafeChildWatcher"

          * "FastChildWatcher"

          * "PidfdChildWatcher"

        * 사용자 정의 정책

      * 플랫폼 지원

        * 모든 플랫폼

        * 윈도우

          * 윈도우에서의 서브 프로세스 지원

        * macOS

      * Extending

        * Writing a Custom Event Loop

        * Future and Task private constructors

          * "__init__()"

          * "__init__()"

        * Task lifetime support

          * "_register_task()"

          * "_unregister_task()"

          * "_enter_task()"

          * "_leave_task()"

      * 고수준 API 색인

        * 태스크

        * 큐

        * 서브 프로세스

        * 스트림

        * 동기화

        * 예외

      * 저수준 API 색인

        * 이벤트 루프 얻기

        * 이벤트 루프 메서드

        * 트랜스포트

        * 프로토콜

        * 이벤트 루프 정책

      * asyncio로 개발하기

        * 디버그 모드

        * 동시성과 다중 스레드

        * 블로킹 코드 실행하기

        * 로깅

        * await 하지 않은 코루틴 감지

        * 전달되지 않은 예외 감지

    * "socket" --- Low-level networking interface

      * 소켓 패밀리

      * 모듈 내용

        * 예외

          * "error"

          * "herror"

          * "gaierror"

          * "timeout"

        * 상수

          * "AF_UNIX"

          * "AF_INET"

          * "AF_INET6"

          * "AF_UNSPEC"

          * "SOCK_STREAM"

          * "SOCK_DGRAM"

          * "SOCK_RAW"

          * "SOCK_RDM"

          * "SOCK_SEQPACKET"

          * "SOCK_CLOEXEC"

          * "SOCK_NONBLOCK"

          * "SOMAXCONN"

          * "AF_CAN"

          * "PF_CAN"

          * "CAN_BCM"

          * "CAN_RAW_FD_FRAMES"

          * "CAN_RAW_JOIN_FILTERS"

          * "CAN_ISOTP"

          * "CAN_J1939"

          * "AF_DIVERT"

          * "PF_DIVERT"

          * "AF_PACKET"

          * "PF_PACKET"

          * "ETH_P_ALL"

          * "AF_RDS"

          * "PF_RDS"

          * "SOL_RDS"

          * "SIO_RCVALL"

          * "SIO_KEEPALIVE_VALS"

          * "SIO_LOOPBACK_FAST_PATH"

          * "AF_ALG"

          * "SOL_ALG"

          * "AF_VSOCK"

          * "IOCTL_VM_SOCKETS_GET_LOCAL_CID"

          * "AF_LINK"

          * "has_ipv6"

          * "BDADDR_ANY"

          * "BDADDR_LOCAL"

          * "HCI_FILTER"

          * "HCI_TIME_STAMP"

          * "HCI_DATA_DIR"

          * "AF_QIPCRTR"

          * "SCM_CREDS2"

          * "LOCAL_CREDS"

          * "LOCAL_CREDS_PERSISTENT"

          * "SO_INCOMING_CPU"

          * "AF_HYPERV"

          * "HV_PROTOCOL_RAW"

          * "HVSOCKET_CONNECT_TIMEOUT"

          * "HVSOCKET_CONNECT_TIMEOUT_MAX"

          * "HVSOCKET_CONNECTED_SUSPEND"

          * "HVSOCKET_ADDRESS_FLAG_PASSTHRU"

          * "HV_GUID_ZERO"

          * "HV_GUID_WILDCARD"

          * "HV_GUID_BROADCAST"

          * "HV_GUID_CHILDREN"

          * "HV_GUID_LOOPBACK"

          * "HV_GUID_PARENT"

          * "ETHERTYPE_ARP"

          * "ETHERTYPE_IP"

          * "ETHERTYPE_IPV6"

          * "ETHERTYPE_VLAN"

          * "SHUT_RD"

          * "SHUT_WR"

          * "SHUT_RDWR"

        * 함수

          * 소켓 만들기

            * "socket"

            * "socketpair()"

            * "create_connection()"

            * "create_server()"

            * "has_dualstack_ipv6()"

            * "fromfd()"

            * "fromshare()"

            * "SocketType"

          * 기타 함수

            * "close()"

            * "getaddrinfo()"

            * "getfqdn()"

            * "gethostbyname()"

            * "gethostbyname_ex()"

            * "gethostname()"

            * "gethostbyaddr()"

            * "getnameinfo()"

            * "getprotobyname()"

            * "getservbyname()"

            * "getservbyport()"

            * "ntohl()"

            * "ntohs()"

            * "htonl()"

            * "htons()"

            * "inet_aton()"

            * "inet_ntoa()"

            * "inet_pton()"

            * "inet_ntop()"

            * "CMSG_LEN()"

            * "CMSG_SPACE()"

            * "getdefaulttimeout()"

            * "setdefaulttimeout()"

            * "sethostname()"

            * "if_nameindex()"

            * "if_nametoindex()"

            * "if_indextoname()"

            * "send_fds()"

            * "recv_fds()"

      * 소켓 객체

        * "accept()"

        * "bind()"

        * "close()"

        * "connect()"

        * "connect_ex()"

        * "detach()"

        * "dup()"

        * "fileno()"

        * "get_inheritable()"

        * "getpeername()"

        * "getsockname()"

        * "getsockopt()"

        * "getblocking()"

        * "gettimeout()"

        * "ioctl()"

        * "listen()"

        * "makefile()"

        * "recv()"

        * "recvfrom()"

        * "recvmsg()"

        * "recvmsg_into()"

        * "recvfrom_into()"

        * "recv_into()"

        * "send()"

        * "sendall()"

        * "sendto()"

        * "sendmsg()"

        * "sendmsg_afalg()"

        * "sendfile()"

        * "set_inheritable()"

        * "setblocking()"

        * "settimeout()"

        * "setsockopt()"

        * "shutdown()"

        * "share()"

        * "family"

        * "type"

        * "proto"

      * 소켓 시간제한에 대한 참고 사항

        * 시간제한과 "connect" 메서드

        * 시간제한과 "accept" 메서드

      * 예제

    * "ssl" --- TLS/SSL wrapper for socket objects

      * 함수, 상수 및 예외

        * 소켓 생성

        * 컨텍스트 생성

          * "create_default_context()"

        * 예외

          * "SSLError"

            * "library"

            * "reason"

          * "SSLZeroReturnError"

          * "SSLWantReadError"

          * "SSLWantWriteError"

          * "SSLSyscallError"

          * "SSLEOFError"

          * "SSLCertVerificationError"

            * "verify_code"

            * "verify_message"

          * "CertificateError"

        * 난수 생성

          * "RAND_bytes()"

          * "RAND_status()"

          * "RAND_add()"

        * 인증서 처리

          * "cert_time_to_seconds()"

          * "get_server_certificate()"

          * "DER_cert_to_PEM_cert()"

          * "PEM_cert_to_DER_cert()"

          * "get_default_verify_paths()"

          * "enum_certificates()"

          * "enum_crls()"

        * 상수

          * "CERT_NONE"

          * "CERT_OPTIONAL"

          * "CERT_REQUIRED"

          * "VerifyMode"

          * "VERIFY_DEFAULT"

          * "VERIFY_CRL_CHECK_LEAF"

          * "VERIFY_CRL_CHECK_CHAIN"

          * "VERIFY_X509_STRICT"

          * "VERIFY_ALLOW_PROXY_CERTS"

          * "VERIFY_X509_TRUSTED_FIRST"

          * "VERIFY_X509_PARTIAL_CHAIN"

          * "VerifyFlags"

          * "PROTOCOL_TLS"

          * "PROTOCOL_TLS_CLIENT"

          * "PROTOCOL_TLS_SERVER"

          * "PROTOCOL_SSLv23"

          * "PROTOCOL_SSLv3"

          * "PROTOCOL_TLSv1"

          * "PROTOCOL_TLSv1_1"

          * "PROTOCOL_TLSv1_2"

          * "OP_ALL"

          * "OP_NO_SSLv2"

          * "OP_NO_SSLv3"

          * "OP_NO_TLSv1"

          * "OP_NO_TLSv1_1"

          * "OP_NO_TLSv1_2"

          * "OP_NO_TLSv1_3"

          * "OP_NO_RENEGOTIATION"

          * "OP_CIPHER_SERVER_PREFERENCE"

          * "OP_SINGLE_DH_USE"

          * "OP_SINGLE_ECDH_USE"

          * "OP_ENABLE_MIDDLEBOX_COMPAT"

          * "OP_NO_COMPRESSION"

          * "Options"

          * "OP_NO_TICKET"

          * "OP_IGNORE_UNEXPECTED_EOF"

          * "OP_ENABLE_KTLS"

          * "OP_LEGACY_SERVER_CONNECT"

          * "HAS_ALPN"

          * "HAS_NEVER_CHECK_COMMON_NAME"

          * "HAS_ECDH"

          * "HAS_SNI"

          * "HAS_NPN"

          * "HAS_SSLv2"

          * "HAS_SSLv3"

          * "HAS_TLSv1"

          * "HAS_TLSv1_1"

          * "HAS_TLSv1_2"

          * "HAS_TLSv1_3"

          * "CHANNEL_BINDING_TYPES"

          * "OPENSSL_VERSION"

          * "OPENSSL_VERSION_INFO"

          * "OPENSSL_VERSION_NUMBER"

          * "ALERT_DESCRIPTION_HANDSHAKE_FAILURE"

          * "ALERT_DESCRIPTION_INTERNAL_ERROR"

          * "AlertDescription"

          * "SERVER_AUTH"

          * "CLIENT_AUTH"

          * "SSLErrorNumber"

          * "TLSVersion"

          * "MINIMUM_SUPPORTED"

          * "MAXIMUM_SUPPORTED"

          * "SSLv3"

          * "TLSv1"

          * "TLSv1_1"

          * "TLSv1_2"

          * "TLSv1_3"

      * SSL 소켓

        * "SSLSocket"

        * "read()"

        * "write()"

        * "do_handshake()"

        * "getpeercert()"

        * "cipher()"

        * "shared_ciphers()"

        * "compression()"

        * "get_channel_binding()"

        * "selected_alpn_protocol()"

        * "selected_npn_protocol()"

        * "unwrap()"

        * "verify_client_post_handshake()"

        * "version()"

        * "pending()"

        * "context"

        * "server_side"

        * "server_hostname"

        * "session"

        * "session_reused"

      * SSL 컨텍스트

        * "SSLContext"

        * "cert_store_stats()"

        * "load_cert_chain()"

        * "load_default_certs()"

        * "load_verify_locations()"

        * "get_ca_certs()"

        * "get_ciphers()"

        * "set_default_verify_paths()"

        * "set_ciphers()"

        * "set_alpn_protocols()"

        * "set_npn_protocols()"

        * "sni_callback"

        * "set_servername_callback"

        * "load_dh_params()"

        * "set_ecdh_curve()"

        * "wrap_socket()"

        * "sslsocket_class"

        * "wrap_bio()"

        * "sslobject_class"

        * "session_stats()"

        * "check_hostname"

        * "keylog_filename"

        * "maximum_version"

        * "minimum_version"

        * "num_tickets"

        * "options"

        * "post_handshake_auth"

        * "protocol"

        * "hostname_checks_common_name"

        * "security_level"

        * "verify_flags"

        * "verify_mode"

      * 인증서

        * 인증서 체인

        * CA 인증서

        * 결합한 키와 인증서

        * 자체 서명 인증서

      * 예제

        * SSL 지원 검사하기

        * 클라이언트 측 연산

        * 서버 측 연산

      * 비 블로킹 소켓에 대한 참고 사항

      * 메모리 BIO 지원

        * "SSLObject"

        * "MemoryBIO"

          * "pending"

          * "eof"

          * "read()"

          * "write()"

          * "write_eof()"

      * SSL 세션

        * "SSLSession"

          * "id"

          * "time"

          * "timeout"

          * "ticket_lifetime_hint"

          * "has_ticket"

      * 보안 고려 사항

        * 가장 좋은 기본값

        * 수동 설정

          * 인증서 확인

          * 프로토콜 버전

          * 사이퍼 선택

        * 다중 프로세싱

      * TLS 1.3

    * "select" --- Waiting for I/O completion

      * "error"

      * "devpoll()"

      * "epoll()"

      * "poll()"

      * "kqueue()"

      * "kevent()"

      * "select()"

      * "PIPE_BUF"

      * "/dev/poll" 폴링 객체

        * "close()"

        * "closed"

        * "fileno()"

        * "register()"

        * "modify()"

        * "unregister()"

        * "poll()"

      * 에지와 레벨 트리거 폴링 (epoll) 객체

        * "close()"

        * "closed"

        * "fileno()"

        * "fromfd()"

        * "register()"

        * "modify()"

        * "unregister()"

        * "poll()"

      * 폴링 객체

        * "register()"

        * "modify()"

        * "unregister()"

        * "poll()"

      * Kqueue 객체

        * "close()"

        * "closed"

        * "fileno()"

        * "fromfd()"

        * "control()"

      * Kevent 객체

        * "ident"

        * "filter"

        * "flags"

        * "fflags"

        * "data"

        * "udata"

    * "selectors" --- High-level I/O multiplexing

      * 소개

      * 클래스

        * "EVENT_READ"

        * "EVENT_WRITE"

        * "SelectorKey"

          * "fileobj"

          * "fd"

          * "events"

          * "data"

        * "BaseSelector"

          * "register()"

          * "unregister()"

          * "modify()"

          * "select()"

          * "close()"

          * "get_key()"

          * "get_map()"

        * "DefaultSelector"

        * "SelectSelector"

        * "PollSelector"

        * "EpollSelector"

          * "fileno()"

        * "DevpollSelector"

          * "fileno()"

        * "KqueueSelector"

          * "fileno()"

      * 예제

    * "signal" --- Set handlers for asynchronous events

      * 일반 규칙

        * 파이썬 시그널 처리기의 실행

        * 시그널과 스레드

      * 모듈 내용

        * "Signals"

        * "Handlers"

        * "Sigmasks"

        * "SIG_DFL"

        * "SIG_IGN"

        * "SIGABRT"

        * "SIGALRM"

        * "SIGBREAK"

        * "SIGBUS"

        * "SIGCHLD"

        * "SIGCLD"

        * "SIGCONT"

        * "SIGFPE"

        * "SIGHUP"

        * "SIGILL"

        * "SIGINT"

        * "SIGKILL"

        * "SIGPIPE"

        * "SIGSEGV"

        * "SIGSTKFLT"

        * "SIGTERM"

        * "SIGUSR1"

        * "SIGUSR2"

        * "SIGWINCH"

        * "CTRL_C_EVENT"

        * "CTRL_BREAK_EVENT"

        * "NSIG"

        * "ITIMER_REAL"

        * "ITIMER_VIRTUAL"

        * "ITIMER_PROF"

        * "SIG_BLOCK"

        * "SIG_UNBLOCK"

        * "SIG_SETMASK"

        * "ItimerError"

        * "alarm()"

        * "getsignal()"

        * "strsignal()"

        * "valid_signals()"

        * "pause()"

        * "raise_signal()"

        * "pidfd_send_signal()"

        * "pthread_kill()"

        * "pthread_sigmask()"

        * "setitimer()"

        * "getitimer()"

        * "set_wakeup_fd()"

        * "siginterrupt()"

        * "signal()"

        * "sigpending()"

        * "sigwait()"

        * "sigwaitinfo()"

        * "sigtimedwait()"

      * Examples

      * SIGPIPE에 대한 참고 사항

      * Note on Signal Handlers and Exceptions

    * "mmap" --- Memory-mapped file support

      * "mmap"

      * "close()"

      * "closed"

      * "find()"

      * "flush()"

      * "madvise()"

      * "move()"

      * "read()"

      * "read_byte()"

      * "readline()"

      * "resize()"

      * "rfind()"

      * "seek()"

      * "size()"

      * "tell()"

      * "write()"

      * "write_byte()"

      * MADV_* 상수

        * "MADV_NORMAL"

        * "MADV_RANDOM"

        * "MADV_SEQUENTIAL"

        * "MADV_WILLNEED"

        * "MADV_DONTNEED"

        * "MADV_REMOVE"

        * "MADV_DONTFORK"

        * "MADV_DOFORK"

        * "MADV_HWPOISON"

        * "MADV_MERGEABLE"

        * "MADV_UNMERGEABLE"

        * "MADV_SOFT_OFFLINE"

        * "MADV_HUGEPAGE"

        * "MADV_NOHUGEPAGE"

        * "MADV_DONTDUMP"

        * "MADV_DODUMP"

        * "MADV_FREE"

        * "MADV_NOSYNC"

        * "MADV_AUTOSYNC"

        * "MADV_NOCORE"

        * "MADV_CORE"

        * "MADV_PROTECT"

        * "MADV_FREE_REUSABLE"

        * "MADV_FREE_REUSE"

      * MAP_* Constants

        * "MAP_SHARED"

        * "MAP_PRIVATE"

        * "MAP_DENYWRITE"

        * "MAP_EXECUTABLE"

        * "MAP_ANON"

        * "MAP_ANONYMOUS"

        * "MAP_POPULATE"

        * "MAP_STACK"

        * "MAP_ALIGNED_SUPER"

        * "MAP_CONCEAL"

  * 인터넷 데이터 처리

    * "email" --- An email and MIME handling package

      * "email.message": Representing an email message

        * "EmailMessage"

          * "as_string()"

          * "__str__()"

          * "as_bytes()"

          * "__bytes__()"

          * "is_multipart()"

          * "set_unixfrom()"

          * "get_unixfrom()"

          * "__len__()"

          * "__contains__()"

          * "__getitem__()"

          * "__setitem__()"

          * "__delitem__()"

          * "keys()"

          * "values()"

          * "items()"

          * "get()"

          * "get_all()"

          * "add_header()"

          * "replace_header()"

          * "get_content_type()"

          * "get_content_maintype()"

          * "get_content_subtype()"

          * "get_default_type()"

          * "set_default_type()"

          * "set_param()"

          * "del_param()"

          * "get_filename()"

          * "get_boundary()"

          * "set_boundary()"

          * "get_content_charset()"

          * "get_charsets()"

          * "is_attachment()"

          * "get_content_disposition()"

          * "walk()"

          * "get_body()"

          * "iter_attachments()"

          * "iter_parts()"

          * "get_content()"

          * "set_content()"

          * "make_related()"

          * "make_alternative()"

          * "make_mixed()"

          * "add_related()"

          * "add_alternative()"

          * "add_attachment()"

          * "clear()"

          * "clear_content()"

          * "preamble"

          * "epilogue"

          * "defects"

        * "MIMEPart"

      * "email.parser": Parsing email messages

        * FeedParser API

          * "BytesFeedParser"

            * "feed()"

            * "close()"

          * "FeedParser"

        * Parser API

          * "BytesParser"

            * "parse()"

            * "parsebytes()"

          * "BytesHeaderParser"

          * "Parser"

            * "parse()"

            * "parsestr()"

          * "HeaderParser"

          * "message_from_bytes()"

          * "message_from_binary_file()"

          * "message_from_string()"

          * "message_from_file()"

        * 추가 사항

      * "email.generator": Generating MIME documents

        * "BytesGenerator"

          * "flatten()"

          * "clone()"

          * "write()"

        * "Generator"

          * "flatten()"

          * "clone()"

          * "write()"

        * "DecodedGenerator"

      * "email.policy": Policy Objects

        * "Policy"

          * "max_line_length"

          * "linesep"

          * "cte_type"

          * "raise_on_defect"

          * "mangle_from_"

          * "message_factory"

          * "verify_generated_headers"

          * "clone()"

          * "handle_defect()"

          * "register_defect()"

          * "header_max_count()"

          * "header_source_parse()"

          * "header_store_parse()"

          * "header_fetch_parse()"

          * "fold()"

          * "fold_binary()"

        * "EmailPolicy"

          * "utf8"

          * "refold_source"

          * "header_factory"

          * "content_manager"

          * "header_max_count()"

          * "header_source_parse()"

          * "header_store_parse()"

          * "header_fetch_parse()"

          * "fold()"

          * "fold_binary()"

        * "default"

        * "SMTP"

        * "SMTPUTF8"

        * "HTTP"

        * "strict"

        * "Compat32"

          * "mangle_from_"

          * "header_source_parse()"

          * "header_store_parse()"

          * "header_fetch_parse()"

          * "fold()"

          * "fold_binary()"

        * "compat32"

      * "email.errors": Exception and Defect classes

        * "MessageError"

        * "MessageParseError"

        * "HeaderParseError"

        * "BoundaryError"

        * "MultipartConversionError"

        * "HeaderWriteError"

        * "MessageDefect"

        * "HeaderDefect"

      * "email.headerregistry": Custom Header Objects

        * "BaseHeader"

          * "name"

          * "defects"

          * "max_count"

          * "fold()"

        * "UnstructuredHeader"

        * "DateHeader"

          * "datetime"

        * "AddressHeader"

          * "groups"

          * "addresses"

        * "SingleAddressHeader"

          * "address"

        * "MIMEVersionHeader"

          * "version"

          * "major"

          * "minor"

        * "ParameterizedMIMEHeader"

          * "params"

        * "ContentTypeHeader"

          * "content_type"

          * "maintype"

          * "subtype"

        * "ContentDispositionHeader"

          * "content_disposition"

        * "ContentTransferEncoding"

          * "cte"

        * "HeaderRegistry"

          * "map_to_type()"

          * "__getitem__()"

          * "__call__()"

        * "Address"

          * "display_name"

          * "username"

          * "domain"

          * "addr_spec"

          * "__str__()"

        * "Group"

          * "display_name"

          * "addresses"

          * "__str__()"

      * "email.contentmanager": Managing MIME Content

        * "ContentManager"

          * "get_content()"

          * "set_content()"

          * "add_get_handler()"

          * "add_set_handler()"

        * 콘텐츠 관리자 인스턴스

          * "raw_data_manager"

            * "get_content()"

            * "set_content()"

      * "email": 예제

      * "email.message.Message": "compat32" API를 사용하여 이메일 메시
        지 표현하기

        * "Message"

          * "as_string()"

          * "__str__()"

          * "as_bytes()"

          * "__bytes__()"

          * "is_multipart()"

          * "set_unixfrom()"

          * "get_unixfrom()"

          * "attach()"

          * "get_payload()"

          * "set_payload()"

          * "set_charset()"

          * "get_charset()"

          * "__len__()"

          * "__contains__()"

          * "__getitem__()"

          * "__setitem__()"

          * "__delitem__()"

          * "keys()"

          * "values()"

          * "items()"

          * "get()"

          * "get_all()"

          * "add_header()"

          * "replace_header()"

          * "get_content_type()"

          * "get_content_maintype()"

          * "get_content_subtype()"

          * "get_default_type()"

          * "set_default_type()"

          * "get_params()"

          * "get_param()"

          * "set_param()"

          * "del_param()"

          * "set_type()"

          * "get_filename()"

          * "get_boundary()"

          * "set_boundary()"

          * "get_content_charset()"

          * "get_charsets()"

          * "get_content_disposition()"

          * "walk()"

          * "preamble"

          * "epilogue"

          * "defects"

      * "email.mime": Creating email and MIME objects from scratch

        * "MIMEBase"

        * "MIMENonMultipart"

        * "MIMEMultipart"

        * "MIMEApplication"

        * "MIMEAudio"

        * "MIMEImage"

        * "MIMEMessage"

        * "MIMEText"

      * "email.header": Internationalized headers

        * "Header"

          * "append()"

          * "encode()"

          * "__str__()"

          * "__eq__()"

          * "__ne__()"

        * "decode_header()"

        * "make_header()"

      * "email.charset": Representing character sets

        * "Charset"

          * "input_charset"

          * "header_encoding"

          * "body_encoding"

          * "output_charset"

          * "input_codec"

          * "output_codec"

          * "get_body_encoding()"

          * "get_output_charset()"

          * "header_encode()"

          * "header_encode_lines()"

          * "body_encode()"

          * "__str__()"

          * "__eq__()"

          * "__ne__()"

        * "add_charset()"

        * "add_alias()"

        * "add_codec()"

      * "email.encoders": Encoders

        * "encode_quopri()"

        * "encode_base64()"

        * "encode_7or8bit()"

        * "encode_noop()"

      * "email.utils": Miscellaneous utilities

        * "localtime()"

        * "make_msgid()"

        * "quote()"

        * "unquote()"

        * "parseaddr()"

        * "formataddr()"

        * "getaddresses()"

        * "parsedate()"

        * "parsedate_tz()"

        * "parsedate_to_datetime()"

        * "mktime_tz()"

        * "formatdate()"

        * "format_datetime()"

        * "decode_rfc2231()"

        * "encode_rfc2231()"

        * "collapse_rfc2231_value()"

        * "decode_params()"

      * "email.iterators": Iterators

        * "body_line_iterator()"

        * "typed_subpart_iterator()"

        * "_structure()"

    * "json" --- JSON encoder and decoder

      * 기본 사용법

        * "dump()"

        * "dumps()"

        * "load()"

        * "loads()"

      * 인코더와 디코더

        * "JSONDecoder"

          * "decode()"

          * "raw_decode()"

        * "JSONEncoder"

          * "default()"

          * "encode()"

          * "iterencode()"

      * 예외

        * "JSONDecodeError"

          * "msg"

          * "doc"

          * "pos"

          * "lineno"

          * "colno"

      * 표준 준수와 상호 운용성

        * 문자 인코딩

        * 무한대와 NaN 숫자 값

        * 오브젝트 내에서 반복된 이름

        * 오브젝트나 배열이 아닌 최상윗값

        * 구현 제약 사항

      * 명령 줄 인터페이스

        * 명령 줄 옵션

    * "mailbox" --- Manipulate mailboxes in various formats

      * "Mailbox" objects

        * "Mailbox"

          * "add()"

          * "remove()"

          * "__delitem__()"

          * "discard()"

          * "__setitem__()"

          * "iterkeys()"

          * "keys()"

          * "itervalues()"

          * "__iter__()"

          * "values()"

          * "iteritems()"

          * "items()"

          * "get()"

          * "__getitem__()"

          * "get_message()"

          * "get_bytes()"

          * "get_string()"

          * "get_file()"

          * "__contains__()"

          * "__len__()"

          * "clear()"

          * "pop()"

          * "popitem()"

          * "update()"

          * "flush()"

          * "lock()"

          * "unlock()"

          * "close()"

        * "Maildir" objects

          * "Maildir"

            * "colon"

            * "list_folders()"

            * "get_folder()"

            * "add_folder()"

            * "remove_folder()"

            * "clean()"

            * "add()"

            * "__setitem__()"

            * "update()"

            * "flush()"

            * "lock()"

            * "unlock()"

            * "close()"

            * "get_file()"

        * "mbox" objects

          * "mbox"

            * "get_file()"

            * "lock()"

            * "unlock()"

        * "MH" objects

          * "MH"

            * "list_folders()"

            * "get_folder()"

            * "add_folder()"

            * "remove_folder()"

            * "get_sequences()"

            * "set_sequences()"

            * "pack()"

            * "remove()"

            * "__delitem__()"

            * "discard()"

            * "lock()"

            * "unlock()"

            * "get_file()"

            * "flush()"

            * "close()"

        * "Babyl" objects

          * "Babyl"

            * "get_labels()"

            * "get_file()"

            * "lock()"

            * "unlock()"

        * "MMDF" objects

          * "MMDF"

            * "get_file()"

            * "lock()"

            * "unlock()"

      * "Message" objects

        * "Message"

        * "MaildirMessage" objects

          * "MaildirMessage"

            * "get_subdir()"

            * "set_subdir()"

            * "get_flags()"

            * "set_flags()"

            * "add_flag()"

            * "remove_flag()"

            * "get_date()"

            * "set_date()"

            * "get_info()"

            * "set_info()"

        * "mboxMessage" objects

          * "mboxMessage"

            * "get_from()"

            * "set_from()"

            * "get_flags()"

            * "set_flags()"

            * "add_flag()"

            * "remove_flag()"

        * "MHMessage" objects

          * "MHMessage"

            * "get_sequences()"

            * "set_sequences()"

            * "add_sequence()"

            * "remove_sequence()"

        * "BabylMessage" objects

          * "BabylMessage"

            * "get_labels()"

            * "set_labels()"

            * "add_label()"

            * "remove_label()"

            * "get_visible()"

            * "set_visible()"

            * "update_visible()"

        * "MMDFMessage" objects

          * "MMDFMessage"

            * "get_from()"

            * "set_from()"

            * "get_flags()"

            * "set_flags()"

            * "add_flag()"

            * "remove_flag()"

      * 예외

        * "Error"

        * "NoSuchMailboxError"

        * "NotEmptyError"

        * "ExternalClashError"

        * "FormatError"

      * 예

    * "mimetypes" --- Map filenames to MIME types

      * "guess_type()"

      * "guess_all_extensions()"

      * "guess_extension()"

      * "init()"

      * "read_mime_types()"

      * "add_type()"

      * "inited"

      * "knownfiles"

      * "suffix_map"

      * "encodings_map"

      * "types_map"

      * "common_types"

      * MimeTypes 객체

        * "MimeTypes"

          * "suffix_map"

          * "encodings_map"

          * "types_map"

          * "types_map_inv"

          * "guess_extension()"

          * "guess_type()"

          * "guess_all_extensions()"

          * "read()"

          * "readfp()"

          * "read_windows_registry()"

          * "add_type()"

    * "base64" --- Base16, Base32, Base64, Base85 Data Encodings

      * "b64encode()"

      * "b64decode()"

      * "standard_b64encode()"

      * "standard_b64decode()"

      * "urlsafe_b64encode()"

      * "urlsafe_b64decode()"

      * "b32encode()"

      * "b32decode()"

      * "b32hexencode()"

      * "b32hexdecode()"

      * "b16encode()"

      * "b16decode()"

      * "a85encode()"

      * "a85decode()"

      * "b85encode()"

      * "b85decode()"

      * "decode()"

      * "decodebytes()"

      * "encode()"

      * "encodebytes()"

      * Security Considerations

    * "binascii" --- Convert between binary and ASCII

      * "a2b_uu()"

      * "b2a_uu()"

      * "a2b_base64()"

      * "b2a_base64()"

      * "a2b_qp()"

      * "b2a_qp()"

      * "crc_hqx()"

      * "crc32()"

      * "b2a_hex()"

      * "hexlify()"

      * "a2b_hex()"

      * "unhexlify()"

      * "Error"

      * "Incomplete"

    * "quopri" --- Encode and decode MIME quoted-printable data

      * "decode()"

      * "encode()"

      * "decodestring()"

      * "encodestring()"

  * 구조화된 마크업 처리 도구

    * "html" --- HyperText Markup Language support

      * "escape()"

      * "unescape()"

    * "html.parser" --- Simple HTML and XHTML parser

      * "HTMLParser"

      * HTML 구문 분석기 응용 프로그램 예제

      * "HTMLParser" 메서드

        * "feed()"

        * "close()"

        * "reset()"

        * "getpos()"

        * "get_starttag_text()"

        * "handle_starttag()"

        * "handle_endtag()"

        * "handle_startendtag()"

        * "handle_data()"

        * "handle_entityref()"

        * "handle_charref()"

        * "handle_comment()"

        * "handle_decl()"

        * "handle_pi()"

        * "unknown_decl()"

      * 예제

    * "html.entities" --- Definitions of HTML general entities

      * "html5"

      * "entitydefs"

      * "name2codepoint"

      * "codepoint2name"

    * XML 처리 모듈

      * XML 취약점

      * The "defusedxml" Package

    * "xml.etree.ElementTree" --- The ElementTree XML API

      * 자습서

        * XML 트리와 엘리먼트

        * XML 구문 분석하기

        * 비 블로킹 구문 분석을 위한 풀(pull) API

        * 흥미로운 엘리먼트 찾기

        * XML 파일 수정하기

        * XML 문서 구축하기

        * 이름 공간이 있는 XML 구문 분석하기

      * XPath 지원

        * 예

        * 지원되는 XPath 문법

      * 레퍼런스

        * 함수

          * "canonicalize()"

          * "Comment()"

          * "dump()"

          * "fromstring()"

          * "fromstringlist()"

          * "indent()"

          * "iselement()"

          * "iterparse()"

          * "parse()"

          * "ProcessingInstruction()"

          * "register_namespace()"

          * "SubElement()"

          * "tostring()"

          * "tostringlist()"

          * "XML()"

          * "XMLID()"

      * XInclude 지원

        * 예

      * 레퍼런스

        * 함수

          * "default_loader()"

          * "include()"

        * Element 객체

          * "Element"

            * "tag"

            * "text"

            * "tail"

            * "attrib"

            * "clear()"

            * "get()"

            * "items()"

            * "keys()"

            * "set()"

            * "append()"

            * "extend()"

            * "find()"

            * "findall()"

            * "findtext()"

            * "insert()"

            * "iter()"

            * "iterfind()"

            * "itertext()"

            * "makeelement()"

            * "remove()"

        * ElementTree 객체

          * "ElementTree"

            * "_setroot()"

            * "find()"

            * "findall()"

            * "findtext()"

            * "getroot()"

            * "iter()"

            * "iterfind()"

            * "parse()"

            * "write()"

        * QName 객체

          * "QName"

        * TreeBuilder 객체

          * "TreeBuilder"

            * "close()"

            * "data()"

            * "end()"

            * "start()"

            * "comment()"

            * "pi()"

            * "doctype()"

            * "start_ns()"

            * "end_ns()"

          * "C14NWriterTarget"

        * XMLParser 객체

          * "XMLParser"

            * "close()"

            * "feed()"

            * "flush()"

        * XMLPullParser 객체

          * "XMLPullParser"

            * "feed()"

            * "flush()"

            * "close()"

            * "read_events()"

        * 예외

          * "ParseError"

            * "code"

            * "position"

    * "xml.dom" --- The Document Object Model API

      * 모듈 내용

        * "registerDOMImplementation()"

        * "getDOMImplementation()"

        * "EMPTY_NAMESPACE"

        * "XML_NAMESPACE"

        * "XMLNS_NAMESPACE"

        * "XHTML_NAMESPACE"

      * DOM의 객체

        * DOMImplementation 객체

          * "hasFeature()"

          * "createDocument()"

          * "createDocumentType()"

        * Node 객체

          * "nodeType"

          * "parentNode"

          * "attributes"

          * "previousSibling"

          * "nextSibling"

          * "childNodes"

          * "firstChild"

          * "lastChild"

          * "localName"

          * "prefix"

          * "namespaceURI"

          * "nodeName"

          * "nodeValue"

          * "hasAttributes()"

          * "hasChildNodes()"

          * "isSameNode()"

          * "appendChild()"

          * "insertBefore()"

          * "removeChild()"

          * "replaceChild()"

          * "normalize()"

          * "cloneNode()"

        * NodeList 객체

          * "item()"

          * "length"

        * DocumentType 객체

          * "publicId"

          * "systemId"

          * "internalSubset"

          * "name"

          * "entities"

          * "notations"

        * Document 객체

          * "documentElement"

          * "createElement()"

          * "createElementNS()"

          * "createTextNode()"

          * "createComment()"

          * "createProcessingInstruction()"

          * "createAttribute()"

          * "createAttributeNS()"

          * "getElementsByTagName()"

          * "getElementsByTagNameNS()"

        * Element 객체

          * "tagName"

          * "getElementsByTagName()"

          * "getElementsByTagNameNS()"

          * "hasAttribute()"

          * "hasAttributeNS()"

          * "getAttribute()"

          * "getAttributeNode()"

          * "getAttributeNS()"

          * "getAttributeNodeNS()"

          * "removeAttribute()"

          * "removeAttributeNode()"

          * "removeAttributeNS()"

          * "setAttribute()"

          * "setAttributeNode()"

          * "setAttributeNodeNS()"

          * "setAttributeNS()"

        * Attr 객체

          * "name"

          * "localName"

          * "prefix"

          * "value"

        * NamedNodeMap 객체

          * "length"

          * "item()"

        * Comment 객체

          * "data"

        * Text와 CDATASection 객체

          * "data"

        * ProcessingInstruction 객체

          * "target"

          * "data"

        * 예외

          * "DOMException"

          * "DomstringSizeErr"

          * "HierarchyRequestErr"

          * "IndexSizeErr"

          * "InuseAttributeErr"

          * "InvalidAccessErr"

          * "InvalidCharacterErr"

          * "InvalidModificationErr"

          * "InvalidStateErr"

          * "NamespaceErr"

          * "NotFoundErr"

          * "NotSupportedErr"

          * "NoDataAllowedErr"

          * "NoModificationAllowedErr"

          * "SyntaxErr"

          * "WrongDocumentErr"

      * 규격 준수

        * 형 매핑

        * 접근자 메서드

    * "xml.dom.minidom" --- Minimal DOM implementation

      * "parse()"

      * "parseString()"

      * DOM 객체

        * "unlink()"

        * "writexml()"

        * "toxml()"

        * "toprettyxml()"

      * DOM 예제

      * minidom과 DOM 표준

    * "xml.dom.pulldom" --- Support for building partial DOM trees

      * "PullDom"

      * "SAX2DOM"

      * "parse()"

      * "parseString()"

      * "default_bufsize"

      * DOMEventStream 객체

        * "DOMEventStream"

          * "getEvent()"

          * "expandNode()"

          * "reset()"

    * "xml.sax" --- Support for SAX2 parsers

      * "make_parser()"

      * "parse()"

      * "parseString()"

      * "SAXException"

      * "SAXParseException"

      * "SAXNotRecognizedException"

      * "SAXNotSupportedException"

      * SAXException 객체

        * "getMessage()"

        * "getException()"

    * "xml.sax.handler" --- Base classes for SAX handlers

      * "ContentHandler"

      * "DTDHandler"

      * "EntityResolver"

      * "ErrorHandler"

      * "LexicalHandler"

      * "feature_namespaces"

      * "feature_namespace_prefixes"

      * "feature_string_interning"

      * "feature_validation"

      * "feature_external_ges"

      * "feature_external_pes"

      * "all_features"

      * "property_lexical_handler"

      * "property_declaration_handler"

      * "property_dom_node"

      * "property_xml_string"

      * "all_properties"

      * ContentHandler 객체

        * "setDocumentLocator()"

        * "startDocument()"

        * "endDocument()"

        * "startPrefixMapping()"

        * "endPrefixMapping()"

        * "startElement()"

        * "endElement()"

        * "startElementNS()"

        * "endElementNS()"

        * "characters()"

        * "ignorableWhitespace()"

        * "processingInstruction()"

        * "skippedEntity()"

      * DTDHandler 객체

        * "notationDecl()"

        * "unparsedEntityDecl()"

      * EntityResolver 객체

        * "resolveEntity()"

      * ErrorHandler 객체

        * "error()"

        * "fatalError()"

        * "warning()"

      * LexicalHandler Objects

        * "comment()"

        * "startDTD()"

        * "endDTD()"

        * "startCDATA()"

        * "endCDATA()"

    * "xml.sax.saxutils" --- SAX Utilities

      * "escape()"

      * "unescape()"

      * "quoteattr()"

      * "XMLGenerator"

      * "XMLFilterBase"

      * "prepare_input_source()"

    * "xml.sax.xmlreader" --- Interface for XML parsers

      * "XMLReader"

      * "IncrementalParser"

      * "Locator"

      * "InputSource"

      * "AttributesImpl"

      * "AttributesNSImpl"

      * XMLReader 객체

        * "parse()"

        * "getContentHandler()"

        * "setContentHandler()"

        * "getDTDHandler()"

        * "setDTDHandler()"

        * "getEntityResolver()"

        * "setEntityResolver()"

        * "getErrorHandler()"

        * "setErrorHandler()"

        * "setLocale()"

        * "getFeature()"

        * "setFeature()"

        * "getProperty()"

        * "setProperty()"

      * IncrementalParser 객체

        * "feed()"

        * "close()"

        * "reset()"

      * Locator 객체

        * "getColumnNumber()"

        * "getLineNumber()"

        * "getPublicId()"

        * "getSystemId()"

      * InputSource 객체

        * "setPublicId()"

        * "getPublicId()"

        * "setSystemId()"

        * "getSystemId()"

        * "setEncoding()"

        * "getEncoding()"

        * "setByteStream()"

        * "getByteStream()"

        * "setCharacterStream()"

        * "getCharacterStream()"

      * "Attributes" 인터페이스

        * "getLength()"

        * "getNames()"

        * "getType()"

        * "getValue()"

      * "AttributesNS" 인터페이스

        * "getValueByQName()"

        * "getNameByQName()"

        * "getQNameByName()"

        * "getQNames()"

    * "xml.parsers.expat" --- Fast XML parsing using Expat

      * "ExpatError"

      * "error"

      * "XMLParserType"

      * "ErrorString()"

      * "ParserCreate()"

      * XMLParser 객체

        * "Parse()"

        * "ParseFile()"

        * "SetBase()"

        * "GetBase()"

        * "GetInputContext()"

        * "ExternalEntityParserCreate()"

        * "SetParamEntityParsing()"

        * "UseForeignDTD()"

        * "SetReparseDeferralEnabled()"

        * "GetReparseDeferralEnabled()"

        * "buffer_size"

        * "buffer_text"

        * "buffer_used"

        * "ordered_attributes"

        * "specified_attributes"

        * "ErrorByteIndex"

        * "ErrorCode"

        * "ErrorColumnNumber"

        * "ErrorLineNumber"

        * "CurrentByteIndex"

        * "CurrentColumnNumber"

        * "CurrentLineNumber"

        * "XmlDeclHandler()"

        * "StartDoctypeDeclHandler()"

        * "EndDoctypeDeclHandler()"

        * "ElementDeclHandler()"

        * "AttlistDeclHandler()"

        * "StartElementHandler()"

        * "EndElementHandler()"

        * "ProcessingInstructionHandler()"

        * "CharacterDataHandler()"

        * "UnparsedEntityDeclHandler()"

        * "EntityDeclHandler()"

        * "NotationDeclHandler()"

        * "StartNamespaceDeclHandler()"

        * "EndNamespaceDeclHandler()"

        * "CommentHandler()"

        * "StartCdataSectionHandler()"

        * "EndCdataSectionHandler()"

        * "DefaultHandler()"

        * "DefaultHandlerExpand()"

        * "NotStandaloneHandler()"

        * "ExternalEntityRefHandler()"

      * ExpatError 예외

        * "code"

        * "lineno"

        * "offset"

      * 예

      * 콘텐츠 모델 기술

      * Expat 에러 상수

        * "codes"

        * "messages"

        * "XML_ERROR_ASYNC_ENTITY"

        * "XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF"

        * "XML_ERROR_BAD_CHAR_REF"

        * "XML_ERROR_BINARY_ENTITY_REF"

        * "XML_ERROR_DUPLICATE_ATTRIBUTE"

        * "XML_ERROR_INCORRECT_ENCODING"

        * "XML_ERROR_INVALID_TOKEN"

        * "XML_ERROR_JUNK_AFTER_DOC_ELEMENT"

        * "XML_ERROR_MISPLACED_XML_PI"

        * "XML_ERROR_NO_ELEMENTS"

        * "XML_ERROR_NO_MEMORY"

        * "XML_ERROR_PARAM_ENTITY_REF"

        * "XML_ERROR_PARTIAL_CHAR"

        * "XML_ERROR_RECURSIVE_ENTITY_REF"

        * "XML_ERROR_SYNTAX"

        * "XML_ERROR_TAG_MISMATCH"

        * "XML_ERROR_UNCLOSED_TOKEN"

        * "XML_ERROR_UNDEFINED_ENTITY"

        * "XML_ERROR_UNKNOWN_ENCODING"

        * "XML_ERROR_UNCLOSED_CDATA_SECTION"

        * "XML_ERROR_EXTERNAL_ENTITY_HANDLING"

        * "XML_ERROR_NOT_STANDALONE"

        * "XML_ERROR_UNEXPECTED_STATE"

        * "XML_ERROR_ENTITY_DECLARED_IN_PE"

        * "XML_ERROR_FEATURE_REQUIRES_XML_DTD"

        * "XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING"

        * "XML_ERROR_UNBOUND_PREFIX"

        * "XML_ERROR_UNDECLARING_PREFIX"

        * "XML_ERROR_INCOMPLETE_PE"

        * "XML_ERROR_XML_DECL"

        * "XML_ERROR_TEXT_DECL"

        * "XML_ERROR_PUBLICID"

        * "XML_ERROR_SUSPENDED"

        * "XML_ERROR_NOT_SUSPENDED"

        * "XML_ERROR_ABORTED"

        * "XML_ERROR_FINISHED"

        * "XML_ERROR_SUSPEND_PE"

        * "XML_ERROR_RESERVED_PREFIX_XML"

        * "XML_ERROR_RESERVED_PREFIX_XMLNS"

        * "XML_ERROR_RESERVED_NAMESPACE_URI"

        * "XML_ERROR_INVALID_ARGUMENT"

        * "XML_ERROR_NO_BUFFER"

        * "XML_ERROR_AMPLIFICATION_LIMIT_BREACH"

  * 인터넷 프로토콜과 지원

    * "webbrowser" --- Convenient web-browser controller

      * "Error"

      * "open()"

      * "open_new()"

      * "open_new_tab()"

      * "get()"

      * "register()"

      * 브라우저 제어기 객체

        * "name"

        * "open()"

        * "open_new()"

        * "open_new_tab()"

    * "wsgiref" --- WSGI Utilities and Reference Implementation

      * "wsgiref.util" -- WSGI 환경 유틸리티

        * "guess_scheme()"

        * "request_uri()"

        * "application_uri()"

        * "shift_path_info()"

        * "setup_testing_defaults()"

        * "is_hop_by_hop()"

        * "FileWrapper"

      * "wsgiref.headers" -- WSGI 응답 헤더 도구

        * "Headers"

          * "get_all()"

          * "add_header()"

      * "wsgiref.simple_server" -- 간단한 WSGI HTTP 서버

        * "make_server()"

        * "demo_app()"

        * "WSGIServer"

          * "set_app()"

          * "get_app()"

        * "WSGIRequestHandler"

          * "get_environ()"

          * "get_stderr()"

          * "handle()"

      * "wsgiref.validate" --- WSGI 적합성 검사기

        * "validator()"

      * "wsgiref.handlers" -- 서버/게이트웨이 베이스 클래스

        * "CGIHandler"

        * "IISCGIHandler"

        * "BaseCGIHandler"

        * "SimpleHandler"

        * "BaseHandler"

          * "run()"

          * "_write()"

          * "_flush()"

          * "get_stdin()"

          * "get_stderr()"

          * "add_cgi_vars()"

          * "wsgi_multithread"

          * "wsgi_multiprocess"

          * "wsgi_run_once"

          * "os_environ"

          * "server_software"

          * "get_scheme()"

          * "setup_environ()"

          * "log_exception()"

          * "traceback_limit"

          * "error_output()"

          * "error_status"

          * "error_headers"

          * "error_body"

          * "wsgi_file_wrapper"

          * "sendfile()"

          * "origin_server"

          * "http_version"

        * "read_environ()"

      * "wsgiref.types" -- WSGI types for static type checking

        * "StartResponse"

        * "WSGIEnvironment"

        * "WSGIApplication"

        * "InputStream"

        * "ErrorStream"

        * "FileWrapper"

      * 예제

    * "urllib" --- URL handling modules

    * "urllib.request" --- Extensible library for opening URLs

      * "urlopen()"

      * "install_opener()"

      * "build_opener()"

      * "pathname2url()"

      * "url2pathname()"

      * "getproxies()"

      * "Request"

      * "OpenerDirector"

      * "BaseHandler"

      * "HTTPDefaultErrorHandler"

      * "HTTPRedirectHandler"

      * "HTTPCookieProcessor"

      * "ProxyHandler"

      * "HTTPPasswordMgr"

      * "HTTPPasswordMgrWithDefaultRealm"

      * "HTTPPasswordMgrWithPriorAuth"

      * "AbstractBasicAuthHandler"

      * "HTTPBasicAuthHandler"

      * "ProxyBasicAuthHandler"

      * "AbstractDigestAuthHandler"

      * "HTTPDigestAuthHandler"

      * "ProxyDigestAuthHandler"

      * "HTTPHandler"

      * "HTTPSHandler"

      * "FileHandler"

      * "DataHandler"

      * "FTPHandler"

      * "CacheFTPHandler"

      * "UnknownHandler"

      * "HTTPErrorProcessor"

      * Request 객체

        * "full_url"

        * "type"

        * "host"

        * "origin_req_host"

        * "selector"

        * "data"

        * "unverifiable"

        * "method"

        * "get_method()"

        * "add_header()"

        * "add_unredirected_header()"

        * "has_header()"

        * "remove_header()"

        * "get_full_url()"

        * "set_proxy()"

        * "get_header()"

        * "header_items()"

      * OpenerDirector 객체

        * "add_handler()"

        * "open()"

        * "error()"

      * BaseHandler 객체

        * "add_parent()"

        * "close()"

        * "parent"

        * "default_open()"

        * "unknown_open()"

        * "http_error_default()"

      * HTTPRedirectHandler 객체

        * "redirect_request()"

        * "http_error_301()"

        * "http_error_302()"

        * "http_error_303()"

        * "http_error_307()"

        * "http_error_308()"

      * HTTPCookieProcessor 객체

        * "cookiejar"

      * ProxyHandler 객체

      * HTTPPasswordMgr 객체

        * "add_password()"

        * "find_user_password()"

      * HTTPPasswordMgrWithPriorAuth 객체

        * "add_password()"

        * "find_user_password()"

        * "update_authenticated()"

        * "is_authenticated()"

      * AbstractBasicAuthHandler 객체

        * "http_error_auth_reqed()"

      * HTTPBasicAuthHandler 객체

        * "http_error_401()"

      * ProxyBasicAuthHandler 객체

        * "http_error_407()"

      * AbstractDigestAuthHandler 객체

        * "http_error_auth_reqed()"

      * HTTPDigestAuthHandler 객체

        * "http_error_401()"

      * ProxyDigestAuthHandler 객체

        * "http_error_407()"

      * HTTPHandler 객체

        * "http_open()"

      * HTTPSHandler 객체

        * "https_open()"

      * FileHandler 객체

        * "file_open()"

      * DataHandler 객체

        * "data_open()"

      * FTPHandler 객체

        * "ftp_open()"

      * CacheFTPHandler 객체

        * "setTimeout()"

        * "setMaxConns()"

      * UnknownHandler 객체

        * "unknown_open()"

      * HTTPErrorProcessor 객체

        * "http_response()"

        * "https_response()"

      * 예

      * 레거시 인터페이스

        * "urlretrieve()"

        * "urlcleanup()"

        * "URLopener"

          * "open()"

          * "open_unknown()"

          * "retrieve()"

          * "version"

        * "FancyURLopener"

          * "prompt_user_passwd()"

      * "urllib.request" 제약 사항

    * "urllib.response" --- urllib가 사용하는 응답 클래스

      * "addinfourl"

        * "url"

        * "headers"

        * "status"

        * "geturl()"

        * "info()"

        * "code"

        * "getcode()"

    * "urllib.parse" --- Parse URLs into components

      * URL 구문 분석

        * "urlparse()"

        * "parse_qs()"

        * "parse_qsl()"

        * "urlunparse()"

        * "urlsplit()"

        * "urlunsplit()"

        * "urljoin()"

        * "urldefrag()"

        * "unwrap()"

      * URL parsing security

      * ASCII로 인코딩된 바이트열 구문 분석

      * 구조화된 구문 분석 결과

        * "geturl()"

        * "DefragResult"

        * "ParseResult"

        * "SplitResult"

        * "DefragResultBytes"

        * "ParseResultBytes"

        * "SplitResultBytes"

      * URL 인용

        * "quote()"

        * "quote_plus()"

        * "quote_from_bytes()"

        * "unquote()"

        * "unquote_plus()"

        * "unquote_to_bytes()"

        * "urlencode()"

    * "urllib.error" --- Exception classes raised by urllib.request

      * "URLError"

        * "reason"

      * "HTTPError"

        * "url"

        * "code"

        * "reason"

        * "headers"

        * "fp"

      * "ContentTooShortError"

        * "content"

    * "urllib.robotparser" ---  Parser for robots.txt

      * "RobotFileParser"

        * "set_url()"

        * "read()"

        * "parse()"

        * "can_fetch()"

        * "mtime()"

        * "modified()"

        * "crawl_delay()"

        * "request_rate()"

        * "site_maps()"

    * "http" --- HTTP modules

      * "HTTPStatus"

      * HTTP 상태 코드

      * HTTP status category

        * "HTTPMethod"

      * HTTP methods

    * "http.client" --- HTTP protocol client

      * "HTTPConnection"

      * "HTTPSConnection"

      * "HTTPResponse"

      * "parse_headers()"

      * "HTTPException"

      * "NotConnected"

      * "InvalidURL"

      * "UnknownProtocol"

      * "UnknownTransferEncoding"

      * "UnimplementedFileMode"

      * "IncompleteRead"

      * "ImproperConnectionState"

      * "CannotSendRequest"

      * "CannotSendHeader"

      * "ResponseNotReady"

      * "BadStatusLine"

      * "LineTooLong"

      * "RemoteDisconnected"

      * "HTTP_PORT"

      * "HTTPS_PORT"

      * "responses"

      * HTTPConnection 객체

        * "request()"

        * "getresponse()"

        * "set_debuglevel()"

        * "set_tunnel()"

        * "get_proxy_response_headers()"

        * "connect()"

        * "close()"

        * "blocksize"

        * "putrequest()"

        * "putheader()"

        * "endheaders()"

        * "send()"

      * HTTPResponse 객체

        * "read()"

        * "readinto()"

        * "getheader()"

        * "getheaders()"

        * "fileno()"

        * "msg"

        * "version"

        * "url"

        * "headers"

        * "status"

        * "reason"

        * "debuglevel"

        * "closed"

        * "geturl()"

        * "info()"

        * "getcode()"

      * 예

      * HTTPMessage 객체

        * "HTTPMessage"

    * "ftplib" --- FTP protocol client

      * Reference

        * FTP objects

          * "FTP"

            * "set_debuglevel()"

            * "connect()"

            * "getwelcome()"

            * "login()"

            * "abort()"

            * "sendcmd()"

            * "voidcmd()"

            * "retrbinary()"

            * "retrlines()"

            * "set_pasv()"

            * "storbinary()"

            * "storlines()"

            * "transfercmd()"

            * "ntransfercmd()"

            * "mlsd()"

            * "nlst()"

            * "dir()"

            * "rename()"

            * "delete()"

            * "cwd()"

            * "mkd()"

            * "pwd()"

            * "rmd()"

            * "size()"

            * "quit()"

            * "close()"

        * FTP_TLS objects

          * "FTP_TLS"

            * "ssl_version"

            * "auth()"

            * "ccc()"

            * "prot_p()"

            * "prot_c()"

        * Module variables

          * "error_reply"

          * "error_temp"

          * "error_perm"

          * "error_proto"

          * "all_errors"

    * "poplib" --- POP3 protocol client

      * "POP3"

      * "POP3_SSL"

      * "error_proto"

      * POP3 객체

        * "set_debuglevel()"

        * "getwelcome()"

        * "capa()"

        * "user()"

        * "pass_()"

        * "apop()"

        * "rpop()"

        * "stat()"

        * "list()"

        * "retr()"

        * "dele()"

        * "rset()"

        * "noop()"

        * "quit()"

        * "top()"

        * "uidl()"

        * "utf8()"

        * "stls()"

      * POP3 예제

    * "imaplib" --- IMAP4 protocol client

      * "IMAP4"

      * "error"

      * "abort"

      * "readonly"

      * "IMAP4_SSL"

      * "IMAP4_stream"

      * "Internaldate2tuple()"

      * "Int2AP()"

      * "ParseFlags()"

      * "Time2Internaldate()"

      * IMAP4 객체

        * "append()"

        * "authenticate()"

        * "check()"

        * "close()"

        * "copy()"

        * "create()"

        * "delete()"

        * "deleteacl()"

        * "enable()"

        * "expunge()"

        * "fetch()"

        * "getacl()"

        * "getannotation()"

        * "getquota()"

        * "getquotaroot()"

        * "list()"

        * "login()"

        * "login_cram_md5()"

        * "logout()"

        * "lsub()"

        * "myrights()"

        * "namespace()"

        * "noop()"

        * "open()"

        * "partial()"

        * "proxyauth()"

        * "read()"

        * "readline()"

        * "recent()"

        * "rename()"

        * "response()"

        * "search()"

        * "select()"

        * "send()"

        * "setacl()"

        * "setannotation()"

        * "setquota()"

        * "shutdown()"

        * "socket()"

        * "sort()"

        * "starttls()"

        * "status()"

        * "store()"

        * "subscribe()"

        * "thread()"

        * "uid()"

        * "unsubscribe()"

        * "unselect()"

        * "xatom()"

        * "PROTOCOL_VERSION"

        * "debug"

        * "utf8_enabled"

      * IMAP4 예

    * "smtplib" --- SMTP protocol client

      * "SMTP"

      * "SMTP_SSL"

      * "LMTP"

      * "SMTPException"

      * "SMTPServerDisconnected"

      * "SMTPResponseException"

      * "SMTPSenderRefused"

      * "SMTPRecipientsRefused"

      * "SMTPDataError"

      * "SMTPConnectError"

      * "SMTPHeloError"

      * "SMTPNotSupportedError"

      * "SMTPAuthenticationError"

      * SMTP 객체

        * "set_debuglevel()"

        * "docmd()"

        * "connect()"

        * "helo()"

        * "ehlo()"

        * "ehlo_or_helo_if_needed()"

        * "has_extn()"

        * "verify()"

        * "login()"

        * "auth()"

        * "starttls()"

        * "sendmail()"

        * "send_message()"

        * "quit()"

      * SMTP 예

    * "uuid" --- UUID objects according to **RFC 4122**

      * "SafeUUID"

        * "safe"

        * "unsafe"

        * "unknown"

      * "UUID"

      * "bytes"

      * "bytes_le"

      * "fields"

      * "time_low"

      * "time_mid"

      * "time_hi_version"

      * "clock_seq_hi_variant"

      * "clock_seq_low"

      * "node"

      * "time"

      * "clock_seq"

      * "hex"

      * "int"

      * "urn"

      * "variant"

      * "version"

      * "is_safe"

      * "getnode()"

      * "uuid1()"

      * "uuid3()"

      * "uuid4()"

      * "uuid5()"

      * "NAMESPACE_DNS"

      * "NAMESPACE_URL"

      * "NAMESPACE_OID"

      * "NAMESPACE_X500"

      * "RESERVED_NCS"

      * "RFC_4122"

      * "RESERVED_MICROSOFT"

      * "RESERVED_FUTURE"

      * Command-Line Usage

      * 예제

      * Command-Line Example

    * "socketserver" --- A framework for network servers

      * "TCPServer"

      * "UDPServer"

      * "UnixStreamServer"

      * "UnixDatagramServer"

      * 서버 생성 노트

        * "ForkingMixIn"

        * "ThreadingMixIn"

          * "block_on_close"

          * "daemon_threads"

        * "ForkingTCPServer"

        * "ForkingUDPServer"

        * "ThreadingTCPServer"

        * "ThreadingUDPServer"

        * "ForkingUnixStreamServer"

        * "ForkingUnixDatagramServer"

        * "ThreadingUnixStreamServer"

        * "ThreadingUnixDatagramServer"

      * 서버 객체

        * "BaseServer"

          * "fileno()"

          * "handle_request()"

          * "serve_forever()"

          * "service_actions()"

          * "shutdown()"

          * "server_close()"

          * "address_family"

          * "RequestHandlerClass"

          * "server_address"

          * "socket"

          * "allow_reuse_address"

          * "request_queue_size"

          * "socket_type"

          * "timeout"

          * "finish_request()"

          * "get_request()"

          * "handle_error()"

          * "handle_timeout()"

          * "process_request()"

          * "server_activate()"

          * "server_bind()"

          * "verify_request()"

      * 요청 처리기 객체

        * "BaseRequestHandler"

          * "setup()"

          * "handle()"

          * "finish()"

          * "request"

          * "client_address"

          * "server"

        * "StreamRequestHandler"

        * "DatagramRequestHandler"

          * "rfile"

          * "wfile"

      * 예

        * "socketserver.TCPServer" 예

        * "socketserver.UDPServer" 예

        * 비동기 믹스인

    * "http.server" --- HTTP servers

      * "HTTPServer"

      * "ThreadingHTTPServer"

      * "BaseHTTPRequestHandler"

        * "client_address"

        * "server"

        * "close_connection"

        * "requestline"

        * "command"

        * "path"

        * "request_version"

        * "headers"

        * "rfile"

        * "wfile"

        * "server_version"

        * "sys_version"

        * "error_message_format"

        * "error_content_type"

        * "protocol_version"

        * "MessageClass"

        * "responses"

        * "handle()"

        * "handle_one_request()"

        * "handle_expect_100()"

        * "send_error()"

        * "send_response()"

        * "send_header()"

        * "send_response_only()"

        * "end_headers()"

        * "flush_headers()"

        * "log_request()"

        * "log_error()"

        * "log_message()"

        * "version_string()"

        * "date_time_string()"

        * "log_date_time_string()"

        * "address_string()"

      * "SimpleHTTPRequestHandler"

        * "server_version"

        * "extensions_map"

        * "do_HEAD()"

        * "do_GET()"

      * "CGIHTTPRequestHandler"

        * "cgi_directories"

        * "do_POST()"

      * Security Considerations

    * "http.cookies" --- HTTP state management

      * "CookieError"

      * "BaseCookie"

      * "SimpleCookie"

      * 쿠키 객체

        * "value_decode()"

        * "value_encode()"

        * "output()"

        * "js_output()"

        * "load()"

      * Morsel 객체

        * "Morsel"

          * "expires"

          * "path"

          * "comment"

          * "domain"

          * "secure"

          * "version"

          * "httponly"

          * "samesite"

        * "value"

        * "coded_value"

        * "key"

        * "set()"

        * "isReservedKey()"

        * "output()"

        * "js_output()"

        * "OutputString()"

        * "update()"

        * "copy()"

        * "setdefault()"

      * 예제

    * "http.cookiejar" --- Cookie handling for HTTP clients

      * "LoadError"

      * "CookieJar"

      * "FileCookieJar"

      * "CookiePolicy"

      * "DefaultCookiePolicy"

      * "Cookie"

      * CookieJar와 FileCookieJar 객체

        * "add_cookie_header()"

        * "extract_cookies()"

        * "set_policy()"

        * "make_cookies()"

        * "set_cookie_if_ok()"

        * "set_cookie()"

        * "clear()"

        * "clear_session_cookies()"

        * "save()"

        * "load()"

        * "revert()"

        * "filename"

        * "delayload"

      * FileCookieJar 서브 클래스와 웹 브라우저와의 협력

        * "MozillaCookieJar"

        * "LWPCookieJar"

      * CookiePolicy 객체

        * "set_ok()"

        * "return_ok()"

        * "domain_return_ok()"

        * "path_return_ok()"

        * "netscape"

        * "rfc2965"

        * "hide_cookie2"

      * DefaultCookiePolicy 객체

        * "blocked_domains()"

        * "set_blocked_domains()"

        * "is_blocked()"

        * "allowed_domains()"

        * "set_allowed_domains()"

        * "is_not_allowed()"

        * "rfc2109_as_netscape"

        * "strict_domain"

        * "strict_rfc2965_unverifiable"

        * "strict_ns_unverifiable"

        * "strict_ns_domain"

        * "strict_ns_set_initial_dollar"

        * "strict_ns_set_path"

        * "DomainStrictNoDots"

        * "DomainStrictNonDomain"

        * "DomainRFC2965Match"

        * "DomainLiberal"

        * "DomainStrict"

      * Cookie 객체

        * "version"

        * "name"

        * "value"

        * "port"

        * "domain"

        * "path"

        * "secure"

        * "expires"

        * "discard"

        * "comment"

        * "comment_url"

        * "rfc2109"

        * "port_specified"

        * "domain_specified"

        * "domain_initial_dot"

        * "has_nonstandard_attr()"

        * "get_nonstandard_attr()"

        * "set_nonstandard_attr()"

        * "is_expired()"

      * 예

    * "xmlrpc" --- XMLRPC server and client modules

    * "xmlrpc.client" --- XML-RPC client access

      * "ServerProxy"

      * ServerProxy 객체

        * "listMethods()"

        * "methodSignature()"

        * "methodHelp()"

      * DateTime 객체

        * "DateTime"

          * "decode()"

          * "encode()"

      * Binary 객체

        * "Binary"

          * "data"

          * "decode()"

          * "encode()"

      * Fault 객체

        * "Fault"

          * "faultCode"

          * "faultString"

      * ProtocolError 객체

        * "ProtocolError"

          * "url"

          * "errcode"

          * "errmsg"

          * "headers"

      * MultiCall 객체

        * "MultiCall"

      * 편의 함수

        * "dumps()"

        * "loads()"

      * 클라이언트 사용 예

      * 클라이언트와 서버 사용 예

    * "xmlrpc.server" --- Basic XML-RPC servers

      * "SimpleXMLRPCServer"

      * "CGIXMLRPCRequestHandler"

      * "SimpleXMLRPCRequestHandler"

      * SimpleXMLRPCServer 객체

        * "register_function()"

        * "register_instance()"

        * "register_introspection_functions()"

        * "register_multicall_functions()"

        * "rpc_paths"

        * SimpleXMLRPCServer 예제

      * CGIXMLRPCRequestHandler

        * "register_function()"

        * "register_instance()"

        * "register_introspection_functions()"

        * "register_multicall_functions()"

        * "handle_request()"

      * XMLRPC 서버 문서화

        * "DocXMLRPCServer"

        * "DocCGIXMLRPCRequestHandler"

        * "DocXMLRPCRequestHandler"

      * DocXMLRPCServer 객체

        * "set_server_title()"

        * "set_server_name()"

        * "set_server_documentation()"

      * DocCGIXMLRPCRequestHandler

        * "set_server_title()"

        * "set_server_name()"

        * "set_server_documentation()"

    * "ipaddress" --- IPv4/IPv6 manipulation library

      * 편의 팩토리 함수

        * "ip_address()"

        * "ip_network()"

        * "ip_interface()"

      * IP 주소

        * 주소 객체

          * "IPv4Address"

            * "version"

            * "max_prefixlen"

            * "compressed"

            * "exploded"

            * "packed"

            * "reverse_pointer"

            * "is_multicast"

            * "is_private"

            * "is_global"

            * "is_unspecified"

            * "is_reserved"

            * "is_loopback"

            * "is_link_local"

          * "__format__()"

          * "IPv6Address"

            * "compressed"

            * "exploded"

            * "packed"

            * "reverse_pointer"

            * "version"

            * "max_prefixlen"

            * "is_multicast"

            * "is_private"

            * "is_global"

            * "is_unspecified"

            * "is_reserved"

            * "is_loopback"

            * "is_link_local"

            * "is_site_local"

            * "ipv4_mapped"

            * "scope_id"

            * "sixtofour"

            * "teredo"

          * "__format__()"

        * 문자열과 정수로의 변환

        * 연산자

          * 비교 연산자

          * 산술 연산자

      * IP 네트워크 정의

        * 접두사, 네트 마스크 및 호스트 마스크

        * 네트워크 객체

          * "IPv4Network"

            * "version"

            * "max_prefixlen"

            * "is_multicast"

            * "is_private"

            * "is_unspecified"

            * "is_reserved"

            * "is_loopback"

            * "is_link_local"

            * "network_address"

            * "broadcast_address"

            * "hostmask"

            * "netmask"

            * "with_prefixlen"

            * "compressed"

            * "exploded"

            * "with_netmask"

            * "with_hostmask"

            * "num_addresses"

            * "prefixlen"

            * "hosts()"

            * "overlaps()"

            * "address_exclude()"

            * "subnets()"

            * "supernet()"

            * "subnet_of()"

            * "supernet_of()"

            * "compare_networks()"

          * "IPv6Network"

            * "version"

            * "max_prefixlen"

            * "is_multicast"

            * "is_private"

            * "is_unspecified"

            * "is_reserved"

            * "is_loopback"

            * "is_link_local"

            * "network_address"

            * "broadcast_address"

            * "hostmask"

            * "netmask"

            * "with_prefixlen"

            * "compressed"

            * "exploded"

            * "with_netmask"

            * "with_hostmask"

            * "num_addresses"

            * "prefixlen"

            * "hosts()"

            * "overlaps()"

            * "address_exclude()"

            * "subnets()"

            * "supernet()"

            * "subnet_of()"

            * "supernet_of()"

            * "compare_networks()"

            * "is_site_local"

        * 연산자

          * 논리 연산자

          * 이터레이션

          * 주소 컨테이너로서의 네트워크

      * 인터페이스 객체

        * "IPv4Interface"

          * "ip"

          * "network"

          * "with_prefixlen"

          * "with_netmask"

          * "with_hostmask"

        * "IPv6Interface"

          * "ip"

          * "network"

          * "with_prefixlen"

          * "with_netmask"

          * "with_hostmask"

        * 연산자

          * 논리 연산자

      * 다른 모듈 수준 함수

        * "v4_int_to_packed()"

        * "v6_int_to_packed()"

        * "summarize_address_range()"

        * "collapse_addresses()"

        * "get_mixed_type_key()"

      * 맞춤 예외

        * "AddressValueError"

        * "NetmaskValueError"

  * 멀티미디어 서비스

    * "wave" --- Read and write WAV files

      * "open()"

      * "Error"

      * Wave_read 객체

        * "Wave_read"

          * "close()"

          * "getnchannels()"

          * "getsampwidth()"

          * "getframerate()"

          * "getnframes()"

          * "getcomptype()"

          * "getcompname()"

          * "getparams()"

          * "readframes()"

          * "rewind()"

          * "getmarkers()"

          * "getmark()"

          * "setpos()"

          * "tell()"

      * Wave_write 객체

        * "Wave_write"

          * "close()"

          * "setnchannels()"

          * "setsampwidth()"

          * "setframerate()"

          * "setnframes()"

          * "setcomptype()"

          * "setparams()"

          * "tell()"

          * "writeframesraw()"

          * "writeframes()"

    * "colorsys" --- Conversions between color systems

      * "rgb_to_yiq()"

      * "yiq_to_rgb()"

      * "rgb_to_hls()"

      * "hls_to_rgb()"

      * "rgb_to_hsv()"

      * "hsv_to_rgb()"

  * 국제화

    * "gettext" --- Multilingual internationalization services

      * GNU **gettext** API

        * "bindtextdomain()"

        * "textdomain()"

        * "gettext()"

        * "dgettext()"

        * "ngettext()"

        * "dngettext()"

        * "pgettext()"

        * "dpgettext()"

        * "npgettext()"

        * "dnpgettext()"

      * 클래스 기반 API

        * "find()"

        * "translation()"

        * "install()"

        * "NullTranslations" 클래스

          * "NullTranslations"

            * "_parse()"

            * "add_fallback()"

            * "gettext()"

            * "ngettext()"

            * "pgettext()"

            * "npgettext()"

            * "info()"

            * "charset()"

            * "install()"

        * "GNUTranslations" 클래스

          * "GNUTranslations"

            * "gettext()"

            * "ngettext()"

            * "pgettext()"

            * "npgettext()"

        * Solaris 메시지 카탈로그 지원

        * Catalog 생성자

      * 프로그램과 모듈의 국제화

        * 모듈 현지화

        * 응용 프로그램 현지화

        * 실행 중 언어 변경

        * 지연된 번역

      * 감사의 말

    * "locale" --- Internationalization services

      * "Error"

      * "setlocale()"

      * "localeconv()"

      * "nl_langinfo()"

        * "CODESET"

        * "D_T_FMT"

        * "D_FMT"

        * "T_FMT"

        * "T_FMT_AMPM"

        * "DAY_1"

        * "DAY_2"

        * "DAY_3"

        * "DAY_4"

        * "DAY_5"

        * "DAY_6"

        * "DAY_7"

        * "ABDAY_1"

        * "ABDAY_2"

        * "ABDAY_3"

        * "ABDAY_4"

        * "ABDAY_5"

        * "ABDAY_6"

        * "ABDAY_7"

        * "MON_1"

        * "MON_2"

        * "MON_3"

        * "MON_4"

        * "MON_5"

        * "MON_6"

        * "MON_7"

        * "MON_8"

        * "MON_9"

        * "MON_10"

        * "MON_11"

        * "MON_12"

        * "ABMON_1"

        * "ABMON_2"

        * "ABMON_3"

        * "ABMON_4"

        * "ABMON_5"

        * "ABMON_6"

        * "ABMON_7"

        * "ABMON_8"

        * "ABMON_9"

        * "ABMON_10"

        * "ABMON_11"

        * "ABMON_12"

        * "RADIXCHAR"

        * "THOUSEP"

        * "YESEXPR"

        * "NOEXPR"

        * "CRNCYSTR"

        * "ERA"

        * "ERA_D_T_FMT"

        * "ERA_D_FMT"

        * "ERA_T_FMT"

        * "ALT_DIGITS"

      * "getdefaultlocale()"

      * "getlocale()"

      * "getpreferredencoding()"

      * "getencoding()"

      * "normalize()"

      * "resetlocale()"

      * "strcoll()"

      * "strxfrm()"

      * "format_string()"

      * "currency()"

      * "str()"

      * "delocalize()"

      * "localize()"

      * "atof()"

      * "atoi()"

      * "LC_CTYPE"

      * "LC_COLLATE"

      * "LC_TIME"

      * "LC_MONETARY"

      * "LC_MESSAGES"

      * "LC_NUMERIC"

      * "LC_ALL"

      * "CHAR_MAX"

      * 배경, 세부 사항, 힌트, 팁 및 경고

      * 확장 작성자와 파이썬을 내장하는 프로그램의 경우

      * 메시지 카탈로그에 액세스

        * "gettext()"

        * "dgettext()"

        * "dcgettext()"

        * "textdomain()"

        * "bindtextdomain()"

        * "bind_textdomain_codeset()"

  * 프로그램 프레임워크

    * "turtle" --- 터틀 그래픽

      * 소개

      * Tutorial

        * Starting a turtle environment

        * Basic drawing

          * 펜 제어

          * The turtle's position

        * Making algorithmic patterns

      * How to...

        * Get started as quickly as possible

        * Use the "turtle" module namespace

        * Use turtle graphics in a script

        * Use object-oriented turtle graphics

      * Turtle graphics reference

        * Turtle 메서드

        * TurtleScreen/Screen의 메서드

      * RawTurtle/Turtl의 메서드와 해당 함수

        * 거북이 움직임

          * "forward()"

          * "fd()"

          * "back()"

          * "bk()"

          * "backward()"

          * "right()"

          * "rt()"

          * "left()"

          * "lt()"

          * "goto()"

          * "setpos()"

          * "setposition()"

          * "teleport()"

          * "setx()"

          * "sety()"

          * "setheading()"

          * "seth()"

          * "home()"

          * "circle()"

          * "dot()"

          * "stamp()"

          * "clearstamp()"

          * "clearstamps()"

          * "undo()"

          * "speed()"

        * 거북이의 상태 보고

          * "position()"

          * "pos()"

          * "towards()"

          * "xcor()"

          * "ycor()"

          * "heading()"

          * "distance()"

        * 측정 설정

          * "degrees()"

          * "radians()"

        * 펜 제어

          * 그리기 상태

            * "pendown()"

            * "pd()"

            * "down()"

            * "penup()"

            * "pu()"

            * "up()"

            * "pensize()"

            * "width()"

            * "pen()"

            * "isdown()"

          * 색상 제어

            * "pencolor()"

            * "fillcolor()"

            * "color()"

          * 채우기

            * "filling()"

            * "begin_fill()"

            * "end_fill()"

          * 더 많은 그리기 제어

            * "reset()"

            * "clear()"

            * "write()"

        * 거북이 상태

          * 가시성

            * "hideturtle()"

            * "ht()"

            * "showturtle()"

            * "st()"

            * "isvisible()"

          * 외관

            * "shape()"

            * "resizemode()"

            * "shapesize()"

            * "turtlesize()"

            * "shearfactor()"

            * "tilt()"

            * "settiltangle()"

            * "tiltangle()"

            * "shapetransform()"

            * "get_shapepoly()"

        * 이벤트 사용하기

          * "onrelease()"

          * "ondrag()"

        * 특수 Turtle 메서드

          * "begin_poly()"

          * "end_poly()"

          * "get_poly()"

          * "clone()"

          * "getturtle()"

          * "getpen()"

          * "getscreen()"

          * "setundobuffer()"

          * "undobufferentries()"

        * 복합 모양

      * TurtleScreen/Screen 메서드와 해당 함수

        * 창 제어

          * "bgcolor()"

          * "bgpic()"

          * "clearscreen()"

          * "resetscreen()"

          * "screensize()"

          * "setworldcoordinates()"

        * 애니메이션 제어

          * "delay()"

          * "tracer()"

          * "update()"

        * 화면 이벤트 사용하기

          * "listen()"

          * "onkey()"

          * "onkeyrelease()"

          * "onkeypress()"

          * "onclick()"

          * "onscreenclick()"

          * "ontimer()"

          * "mainloop()"

          * "done()"

        * 입력 메서드

          * "textinput()"

          * "numinput()"

        * 설정과 특수 메서드

          * "mode()"

          * "colormode()"

          * "getcanvas()"

          * "getshapes()"

          * "register_shape()"

          * "addshape()"

          * "turtles()"

          * "window_height()"

          * "window_width()"

        * TurtleScreen에서 상속되지 않은, Screen만의 메서드

          * "bye()"

          * "exitonclick()"

          * "setup()"

          * "title()"

      * 공개 클래스

        * "RawTurtle"

        * "RawPen"

        * "Turtle"

        * "TurtleScreen"

        * "Screen"

        * "ScrolledCanvas"

        * "Shape"

          * "addcomponent()"

        * "Vec2D"

      * Explanation

      * 도움말과 구성

        * 도움말 사용법

        * 독스트링을 다른 언어로 번역

          * "write_docstringdict()"

        * Screen과 Turtle을 구성하는 방법

      * "turtledemo" --- 데모 스크립트

      * 파이썬 2.6 이후의 변화

      * 파이썬 3.0 이후의 변화

    * "cmd" --- Support for line-oriented command interpreters

      * "Cmd"

      * Cmd 객체

        * "cmdloop()"

        * "do_help()"

        * "onecmd()"

        * "emptyline()"

        * "default()"

        * "completedefault()"

        * "columnize()"

        * "precmd()"

        * "postcmd()"

        * "preloop()"

        * "postloop()"

        * "prompt"

        * "identchars"

        * "lastcmd"

        * "cmdqueue"

        * "intro"

        * "doc_header"

        * "misc_header"

        * "undoc_header"

        * "ruler"

        * "use_rawinput"

      * Cmd 예

    * "shlex" --- Simple lexical analysis

      * "split()"

      * "join()"

      * "quote()"

      * "shlex"

      * shlex 객체

        * "get_token()"

        * "push_token()"

        * "read_token()"

        * "sourcehook()"

        * "push_source()"

        * "pop_source()"

        * "error_leader()"

        * "commenters"

        * "wordchars"

        * "whitespace"

        * "escape"

        * "quotes"

        * "escapedquotes"

        * "whitespace_split"

        * "infile"

        * "instream"

        * "source"

        * "debug"

        * "lineno"

        * "token"

        * "eof"

        * "punctuation_chars"

      * 구문 분석 규칙

      * 셸과의 호환성 향상

  * Tk를 사용한 그래픽 사용자 인터페이스

    * "tkinter" --- Python interface to Tcl/Tk

      * Architecture

      * Tkinter 모듈

        * "Tk"

          * "tk"

          * "master"

          * "children"

        * "Tcl()"

      * Tkinter 구명조끼

        * A Hello World Program

        * Important Tk Concepts

        * Understanding How Tkinter Wraps Tcl/Tk

        * How do I...? What option does...?

        * Navigating the Tcl/Tk Reference Manual

      * Threading model

      * 간편한 레퍼런스

        * 옵션 설정

        * 패커

        * 패커 옵션

        * 위젯 변수 결합하기

        * 창 관리자

        * Tk 옵션 데이터형

        * 바인딩과 이벤트

        * index 매개 변수

        * 이미지

      * 파일 처리기

        * "createfilehandler()"

        * "deletefilehandler()"

        * "READABLE"

        * "WRITABLE"

        * "EXCEPTION"

    * "tkinter.colorchooser" --- Color choosing dialog

      * "Chooser"

      * "askcolor()"

    * "tkinter.font" --- Tkinter font wrapper

      * "NORMAL"

      * "BOLD"

      * "ITALIC"

      * "ROMAN"

      * "Font"

        * "actual()"

        * "cget()"

        * "config()"

        * "copy()"

        * "measure()"

        * "metrics()"

      * "families()"

      * "names()"

      * "nametofont()"

    * Tkinter 대화 상자

      * "tkinter.simpledialog" --- 표준 Tkinter 입력 대화 상자

        * "askfloat()"

        * "askinteger()"

        * "askstring()"

        * "Dialog"

          * "body()"

          * "buttonbox()"

      * "tkinter.filedialog" --- 파일 선택 대화 상자

        * 네이티브 로드/저장 대화 상자

          * "askopenfile()"

          * "askopenfiles()"

          * "asksaveasfile()"

          * "askopenfilename()"

          * "askopenfilenames()"

          * "asksaveasfilename()"

          * "askdirectory()"

          * "Open"

          * "SaveAs"

          * "Directory"

          * "FileDialog"

            * "cancel_command()"

            * "dirs_double_event()"

            * "dirs_select_event()"

            * "files_double_event()"

            * "files_select_event()"

            * "filter_command()"

            * "get_filter()"

            * "get_selection()"

            * "go()"

            * "ok_event()"

            * "quit()"

            * "set_filter()"

            * "set_selection()"

          * "LoadFileDialog"

            * "ok_command()"

          * "SaveFileDialog"

            * "ok_command()"

      * "tkinter.commondialog" --- 대화창 템플릿

        * "Dialog"

          * "show()"

    * "tkinter.messagebox" --- Tkinter message prompts

      * "Message"

        * "show()"

      * "showinfo()"

      * "showwarning()"

      * "showerror()"

      * "askquestion()"

      * "askokcancel()"

      * "askretrycancel()"

      * "askyesno()"

      * "askyesnocancel()"

      * "ABORT"

      * "RETRY"

      * "IGNORE"

      * "OK"

      * "CANCEL"

      * "YES"

      * "NO"

      * "ABORTRETRYIGNORE"

      * "OKCANCEL"

      * "RETRYCANCEL"

      * "YESNO"

      * "YESNOCANCEL"

      * "ERROR"

      * "INFO"

      * "QUESTION"

      * "WARNING"

    * "tkinter.scrolledtext" --- Scrolled Text Widget

      * "ScrolledText"

        * "frame"

        * "vbar"

    * "tkinter.dnd" --- Drag and drop support

      * "DndHandler"

        * "cancel()"

        * "finish()"

        * "on_motion()"

        * "on_release()"

      * "dnd_start()"

    * "tkinter.ttk" --- Tk themed widgets

      * Ttk 사용하기

      * Ttk 위젯

      * Widget

        * 표준 옵션

        * 스크롤 가능한 위젯 옵션

        * 레이블 옵션

        * 호환성 옵션

        * 위젯 상태

        * ttk.Widget

          * "Widget"

            * "identify()"

            * "instate()"

            * "state()"

      * Combobox

        * 옵션

        * 가상 이벤트

        * ttk.Combobox

          * "Combobox"

            * "current()"

            * "get()"

            * "set()"

      * Spinbox

        * 옵션

        * 가상 이벤트

        * ttk.Spinbox

          * "Spinbox"

            * "get()"

            * "set()"

      * Notebook

        * 옵션

        * 탭 옵션

        * 탭 식별자

        * 가상 이벤트

        * ttk.Notebook

          * "Notebook"

            * "add()"

            * "forget()"

            * "hide()"

            * "identify()"

            * "index()"

            * "insert()"

            * "select()"

            * "tab()"

            * "tabs()"

            * "enable_traversal()"

      * Progressbar

        * 옵션

        * ttk.Progressbar

          * "Progressbar"

            * "start()"

            * "step()"

            * "stop()"

      * Separator

        * 옵션

      * Sizegrip

        * 플랫폼별 노트

        * 버그

      * Treeview

        * 옵션

        * 항목 옵션

        * 태그 옵션

        * 열 식별자

        * 가상 이벤트

        * ttk.Treeview

          * "Treeview"

            * "bbox()"

            * "get_children()"

            * "set_children()"

            * "column()"

            * "delete()"

            * "detach()"

            * "exists()"

            * "focus()"

            * "heading()"

            * "identify()"

            * "identify_row()"

            * "identify_column()"

            * "identify_region()"

            * "identify_element()"

            * "index()"

            * "insert()"

            * "item()"

            * "move()"

            * "next()"

            * "parent()"

            * "prev()"

            * "reattach()"

            * "see()"

            * "selection()"

            * "selection_set()"

            * "selection_add()"

            * "selection_remove()"

            * "selection_toggle()"

            * "set()"

            * "tag_bind()"

            * "tag_configure()"

            * "tag_has()"

            * "xview()"

            * "yview()"

      * Ttk 스타일링

        * "Style"

          * "configure()"

          * "map()"

          * "lookup()"

          * "layout()"

          * "element_create()"

          * "element_names()"

          * "element_options()"

          * "theme_create()"

          * "theme_settings()"

          * "theme_names()"

          * "theme_use()"

        * 레이아웃

    * "tkinter.tix" --- Extension widgets for Tk

      * Using Tix

        * "Tk"

      * Tix Widgets

        * Basic Widgets

          * "Balloon"

          * "ButtonBox"

          * "ComboBox"

          * "Control"

          * "LabelEntry"

          * "LabelFrame"

          * "Meter"

          * "OptionMenu"

          * "PopupMenu"

          * "Select"

          * "StdButtonBox"

        * File Selectors

          * "DirList"

          * "DirTree"

          * "DirSelectDialog"

          * "DirSelectBox"

          * "ExFileSelectBox"

          * "FileSelectBox"

          * "FileEntry"

        * Hierarchical ListBox

          * "HList"

          * "CheckList"

          * "Tree"

        * Tabular ListBox

          * "TList"

        * Manager Widgets

          * "PanedWindow"

          * "ListNoteBook"

          * "NoteBook"

        * Image Types

        * Miscellaneous Widgets

          * "InputOnly"

        * Form Geometry Manager

          * "Form"

      * Tix Commands

        * "tixCommand"

        * "tix_configure()"

        * "tix_cget()"

        * "tix_getbitmap()"

        * "tix_addbitmapdir()"

        * "tix_filedialog()"

        * "tix_getimage()"

        * "tix_option_get()"

        * "tix_resetoptions()"

    * IDLE

      * 메뉴

        * File 메뉴 (셸과 편집기)

        * Edit 메뉴 (셸과 편집기)

        * Format 메뉴 (편집기 창 전용)

        * Run 메뉴 (편집기 창 전용)

        * Shell 메뉴 (셸 창 전용)

        * Debug 메뉴 (셸 창 전용)

        * Options 메뉴 (셸과 편집기)

        * Window 메뉴 (셸과 편집기)

        * Help 메뉴 (셸과 편집기)

        * Context menus

      * Editing and Navigation

        * 편집기 창

        * 키 바인딩

        * 자동 들여쓰기

        * Search and Replace

        * 완성

        * 콜팁

        * 코드 컨텍스트

        * Shell window

        * 텍스트 색상

      * Startup and Code Execution

        * 명령 줄 사용법

        * 시작 실패

        * 사용자 코드 실행하기

        * 셸의 사용자 출력

        * tkinter 응용 프로그램 개발하기

        * 서브 프로세스 없이 실행하기

      * Help and Preferences

        * 도움말 소스

        * 환경 설정

        * macOS의 IDLE

        * 확장

      * idlelib

  * 개발 도구

    * "typing" --- 형 힌트 지원

      * Specification for the Python Type System

      * 형 에일리어스

      * NewType

      * Annotating callable objects

      * 제네릭

      * Annotating tuples

      * The type of class objects

      * Annotating generators and coroutines

      * 사용자 정의 제네릭 형

      * "Any" 형

      * 명목적 대 구조적 서브 타이핑

      * 모듈 내용

        * 특수 타이핑 프리미티브

          * 특수형

            * "Any"

            * "AnyStr"

            * "LiteralString"

            * "Never"

            * "NoReturn"

            * "Self"

            * "TypeAlias"

          * 특수 형태

            * "Union"

            * "Optional"

            * "Concatenate"

            * "Literal"

            * "ClassVar"

            * "Final"

            * "Required"

            * "NotRequired"

            * "Annotated"

            * "TypeGuard"

            * "Unpack"

          * Building generic types and type aliases

            * "Generic"

            * "TypeVar"

              * "__name__"

              * "__covariant__"

              * "__contravariant__"

              * "__infer_variance__"

              * "__bound__"

              * "__constraints__"

            * "TypeVarTuple"

              * "__name__"

            * "ParamSpec"

              * "args"

              * "kwargs"

              * "__name__"

            * "ParamSpecArgs"

            * "ParamSpecKwargs"

            * "TypeAliasType"

              * "__name__"

              * "__module__"

              * "__type_params__"

              * "__value__"

          * 기타 특수 지시자

            * "NamedTuple"

            * "NewType"

              * "__module__"

              * "__name__"

              * "__supertype__"

            * "Protocol"

            * "runtime_checkable()"

            * "TypedDict"

              * "__total__"

              * "__required_keys__"

              * "__optional_keys__"

        * 프로토콜

          * "SupportsAbs"

          * "SupportsBytes"

          * "SupportsComplex"

          * "SupportsFloat"

          * "SupportsIndex"

          * "SupportsInt"

          * "SupportsRound"

        * ABCs for working with IO

          * "IO"

          * "TextIO"

          * "BinaryIO"

        * 함수와 데코레이터

          * "cast()"

          * "assert_type()"

          * "assert_never()"

          * "reveal_type()"

          * "dataclass_transform()"

          * "overload()"

          * "get_overloads()"

          * "clear_overloads()"

          * "final()"

          * "no_type_check()"

          * "no_type_check_decorator()"

          * "override()"

          * "type_check_only()"

        * 인트로스펙션 도우미

          * "get_type_hints()"

          * "get_origin()"

          * "get_args()"

          * "is_typeddict()"

          * "ForwardRef"

        * 상수

          * "TYPE_CHECKING"

        * Deprecated aliases

          * Aliases to built-in types

            * "Dict"

            * "List"

            * "Set"

            * "FrozenSet"

            * "Tuple"

            * "Type"

          * Aliases to types in "collections"

            * "DefaultDict"

            * "OrderedDict"

            * "ChainMap"

            * "Counter"

            * "Deque"

          * Aliases to other concrete types

            * "Pattern"

            * "Match"

            * "Text"

          * Aliases to container ABCs in "collections.abc"

            * "AbstractSet"

            * "ByteString"

            * "Collection"

            * "Container"

            * "ItemsView"

            * "KeysView"

            * "Mapping"

            * "MappingView"

            * "MutableMapping"

            * "MutableSequence"

            * "MutableSet"

            * "Sequence"

            * "ValuesView"

          * Aliases to asynchronous ABCs in "collections.abc"

            * "Coroutine"

            * "AsyncGenerator"

            * "AsyncIterable"

            * "AsyncIterator"

            * "Awaitable"

          * Aliases to other ABCs in "collections.abc"

            * "Iterable"

            * "Iterator"

            * "Callable"

            * "Generator"

            * "Hashable"

            * "Reversible"

            * "Sized"

          * Aliases to "contextlib" ABCs

            * "ContextManager"

            * "AsyncContextManager"

      * Deprecation Timeline of Major Features

    * "pydoc" --- Documentation generator and online help system

    * 파이썬 개발 모드

      * 파이썬 개발 모드의 효과

      * ResourceWarning 예

      * 잘못된 파일 기술자 에러 예

    * "doctest" --- Test interactive Python examples

      * 간단한 사용법: 독스트링에 있는 예제 확인하기

      * 간단한 사용법: 텍스트 파일에 있는 예제 확인하기

      * 작동 방법

        * 어떤 독스트링을 검사합니까?

        * 독스트링 예제는 어떻게 인식됩니까?

        * 실행 컨텍스트란 무엇입니까?

        * 예외는 어떻게 됩니까?

        * 옵션 플래그

          * "DONT_ACCEPT_TRUE_FOR_1"

          * "DONT_ACCEPT_BLANKLINE"

          * "NORMALIZE_WHITESPACE"

          * "ELLIPSIS"

          * "IGNORE_EXCEPTION_DETAIL"

          * "SKIP"

          * "COMPARISON_FLAGS"

          * "REPORT_UDIFF"

          * "REPORT_CDIFF"

          * "REPORT_NDIFF"

          * "REPORT_ONLY_FIRST_FAILURE"

          * "FAIL_FAST"

          * "REPORTING_FLAGS"

          * "register_optionflag()"

        * 지시자

        * 경고

      * 기본 API

        * "testfile()"

        * "testmod()"

        * "run_docstring_examples()"

      * Unittest API

        * "DocFileSuite()"

        * "DocTestSuite()"

        * "failureException"

        * "set_unittest_reportflags()"

      * 고급 API

        * DocTest 객체

          * "DocTest"

            * "examples"

            * "globs"

            * "name"

            * "filename"

            * "lineno"

            * "docstring"

        * Example 객체

          * "Example"

            * "source"

            * "want"

            * "exc_msg"

            * "lineno"

            * "indent"

            * "options"

        * DocTestFinder 객체

          * "DocTestFinder"

            * "find()"

        * DocTestParser 객체

          * "DocTestParser"

            * "get_doctest()"

            * "get_examples()"

            * "parse()"

        * DocTestRunner 객체

          * "DocTestRunner"

            * "report_start()"

            * "report_success()"

            * "report_failure()"

            * "report_unexpected_exception()"

            * "run()"

            * "summarize()"

        * OutputChecker 객체

          * "OutputChecker"

            * "check_output()"

            * "output_difference()"

      * 디버깅

        * "script_from_examples()"

        * "testsource()"

        * "debug()"

        * "debug_src()"

        * "DebugRunner"

        * "DocTestFailure"

        * "test"

        * "example"

        * "got"

        * "UnexpectedException"

        * "test"

        * "example"

        * "exc_info"

      * 맺음말

    * "unittest" --- Unit testing framework

      * 기본 예시

      * 명령행 인터페이스

        * 명령행 옵션

      * 테스트 탐색(Discovery)

      * 테스트 코드 구조 잡기

      * 이전의 테스트 코드를 다시 사용하기

      * 테스트 건너뛰기와 예상된 실패

        * "skip()"

        * "skipIf()"

        * "skipUnless()"

        * "expectedFailure()"

        * "SkipTest"

      * 부분 테스트(subtest)를 사용하여 테스트 반복 구별 짓기

      * 클래스와 함수

        * 테스트 케이스

          * "TestCase"

            * "setUp()"

            * "tearDown()"

            * "setUpClass()"

            * "tearDownClass()"

            * "run()"

            * "skipTest()"

            * "subTest()"

            * "debug()"

            * "assertEqual()"

            * "assertNotEqual()"

            * "assertTrue()"

            * "assertFalse()"

            * "assertIs()"

            * "assertIsNot()"

            * "assertIsNone()"

            * "assertIsNotNone()"

            * "assertIn()"

            * "assertNotIn()"

            * "assertIsInstance()"

            * "assertNotIsInstance()"

            * "assertRaises()"

            * "assertRaisesRegex()"

            * "assertWarns()"

            * "assertWarnsRegex()"

            * "assertLogs()"

              * "records"

              * "output"

            * "assertNoLogs()"

            * "assertAlmostEqual()"

            * "assertNotAlmostEqual()"

            * "assertGreater()"

            * "assertGreaterEqual()"

            * "assertLess()"

            * "assertLessEqual()"

            * "assertRegex()"

            * "assertNotRegex()"

            * "assertCountEqual()"

            * "addTypeEqualityFunc()"

            * "assertMultiLineEqual()"

            * "assertSequenceEqual()"

            * "assertListEqual()"

            * "assertTupleEqual()"

            * "assertSetEqual()"

            * "assertDictEqual()"

            * "fail()"

            * "failureException"

            * "longMessage"

            * "maxDiff"

            * "countTestCases()"

            * "defaultTestResult()"

            * "id()"

            * "shortDescription()"

            * "addCleanup()"

            * "enterContext()"

            * "doCleanups()"

            * "addClassCleanup()"

            * "enterClassContext()"

            * "doClassCleanups()"

          * "IsolatedAsyncioTestCase"

            * "asyncSetUp()"

            * "asyncTearDown()"

            * "addAsyncCleanup()"

            * "enterAsyncContext()"

            * "run()"

          * "FunctionTestCase"

        * 테스트 분류

          * "TestSuite"

            * "addTest()"

            * "addTests()"

            * "run()"

            * "debug()"

            * "countTestCases()"

            * "__iter__()"

        * 테스트를 로드하고 실행하기

          * "TestLoader"

            * "errors"

            * "loadTestsFromTestCase()"

            * "loadTestsFromModule()"

            * "loadTestsFromName()"

            * "loadTestsFromNames()"

            * "getTestCaseNames()"

            * "discover()"

            * "testMethodPrefix"

            * "sortTestMethodsUsing"

            * "suiteClass"

            * "testNamePatterns"

          * "TestResult"

            * "errors"

            * "failures"

            * "skipped"

            * "expectedFailures"

            * "unexpectedSuccesses"

            * "collectedDurations"

            * "shouldStop"

            * "testsRun"

            * "buffer"

            * "failfast"

            * "tb_locals"

            * "wasSuccessful()"

            * "stop()"

            * "startTest()"

            * "stopTest()"

            * "startTestRun()"

            * "stopTestRun()"

            * "addError()"

            * "addFailure()"

            * "addSuccess()"

            * "addSkip()"

            * "addExpectedFailure()"

            * "addUnexpectedSuccess()"

            * "addSubTest()"

            * "addDuration()"

          * "TextTestResult"

          * "defaultTestLoader"

          * "TextTestRunner"

            * "_makeResult()"

            * "run()"

          * "main()"

          * load_tests 프로토콜

      * 클래스와 모듈 픽스쳐

        * setUpClass 와 tearDownClass

        * setUpModule 과 tearDownModule

          * "addModuleCleanup()"

          * "enterModuleContext()"

          * "doModuleCleanups()"

      * 시그널 처리하기

        * "installHandler()"

        * "registerResult()"

        * "removeResult()"

        * "removeHandler()"

    * "unittest.mock" --- mock object library

      * 간략 지침

      * Mock 클래스

        * "Mock"

          * "assert_called()"

          * "assert_called_once()"

          * "assert_called_with()"

          * "assert_called_once_with()"

          * "assert_any_call()"

          * "assert_has_calls()"

          * "assert_not_called()"

          * "reset_mock()"

          * "mock_add_spec()"

          * "attach_mock()"

          * "configure_mock()"

          * "__dir__()"

          * "_get_child_mock()"

          * "called"

          * "call_count"

          * "return_value"

          * "side_effect"

          * "call_args"

          * "call_args_list"

          * "method_calls"

          * "mock_calls"

          * "__class__"

        * "NonCallableMock"

        * "PropertyMock"

        * "AsyncMock"

          * "assert_awaited()"

          * "assert_awaited_once()"

          * "assert_awaited_with()"

          * "assert_awaited_once_with()"

          * "assert_any_await()"

          * "assert_has_awaits()"

          * "assert_not_awaited()"

          * "reset_mock()"

          * "await_count"

          * "await_args"

          * "await_args_list"

        * 호출

        * 어트리뷰트 삭제

        * 모의 객체 이름과 이름 어트리뷰트

        * 모의 객체를 어트리뷰트로 연결하기

      * 패처

        * patch

          * "patch()"

        * patch.object

          * "object()"

        * patch.dict

          * "dict()"

        * patch.multiple

          * "multiple()"

        * 패처 메서드: start와 stop

          * "stopall()"

        * 내장 패치

        * TEST_PREFIX

        * 패치 데코레이터 중첩하기

        * 패치할 곳

        * 디스크립터와 프락시 객체 패치하기

      * MagicMock과 매직 메서드 지원

        * 매직 메서드 모킹하기

        * 매직 모의 객체

          * "MagicMock"

          * "NonCallableMagicMock"

      * 도우미

        * sentinel

          * "sentinel"

        * DEFAULT

          * "DEFAULT"

        * call

          * "call()"

          * "call_list()"

        * create_autospec

          * "create_autospec()"

        * ANY

          * "ANY"

        * FILTER_DIR

          * "FILTER_DIR"

        * mock_open

          * "mock_open()"

        * 자동 사양

        * 실링 모의 객체 봉인하기

          * "seal()"

      * Order of precedence of "side_effect", "return_value" and
        *wraps*

    * "unittest.mock" --- getting started

      * 모의 객체 사용하기

        * 메서드를 패치하는 모의 객체

        * 객체의 메서드 호출을 위한 모의 객체

        * 클래스 모킹하기

        * 모의 객체 이름 붙이기

        * 모든 호출 추적하기

        * 반환 값과 어트리뷰트 설정하기

        * 모의 객체로 예외 발생시키기

        * 부작용 함수와 이터러블

        * 비동기 이터레이터 모킹하기

        * 비동기 컨텍스트 관리자 모킹하기

        * 기존 객체에서 모의 객체 만들기

        * Using side_effect to return per file content

      * 패치 데코레이터

      * 추가 예

        * 연쇄 호출 모킹하기

        * 부분 모킹

        * 제너레이터 메서드 모킹하기

        * 모든 테스트 메서드에 같은 패치 적용하기

        * 연결되지 않은 메서드 모킹하기

        * 모의 객체로 여러 호출 확인하기

        * 가변 인자에 대처하기

        * 중첩 패치

        * MagicMock으로 딕셔너리 모킹하기

        * Mock 서브 클래스와 그 어트리뷰트

        * patch.dict로 임포트를 모킹하기

        * 호출 순서 추적과 덜 상세한 호출 어서션

        * 더 복잡한 인자 일치

    * 2to3 --- Automated Python 2 to 3 code translation

      * 2to3 사용법

      * 변환자 목록

      * "lib2to3" --- 2to3's library

    * "test" --- Regression tests package for Python

      * "test" 패키지를 위한 단위 테스트 작성하기

      * 명령 줄 인터페이스를 사용하여 테스트 실행하기

    * "test.support" --- 파이썬 테스트 스위트용 유틸리티

      * "TestFailed"

      * "ResourceDenied"

      * "verbose"

      * "is_jython"

      * "is_android"

      * "unix_shell"

      * "LOOPBACK_TIMEOUT"

      * "INTERNET_TIMEOUT"

      * "SHORT_TIMEOUT"

      * "LONG_TIMEOUT"

      * "PGO"

      * "PIPE_MAX_SIZE"

      * "Py_DEBUG"

      * "SOCK_MAX_SIZE"

      * "TEST_SUPPORT_DIR"

      * "TEST_HOME_DIR"

      * "TEST_DATA_DIR"

      * "MAX_Py_ssize_t"

      * "max_memuse"

      * "real_max_memuse"

      * "MISSING_C_DOCSTRINGS"

      * "HAVE_DOCSTRINGS"

      * "TEST_HTTP_URL"

      * "ALWAYS_EQ"

      * "NEVER_EQ"

      * "LARGEST"

      * "SMALLEST"

      * "busy_retry()"

      * "sleeping_retry()"

      * "is_resource_enabled()"

      * "python_is_optimized()"

      * "with_pymalloc()"

      * "requires()"

      * "sortdict()"

      * "findfile()"

      * "get_pagesize()"

      * "setswitchinterval()"

      * "check_impl_detail()"

      * "set_memlimit()"

      * "record_original_stdout()"

      * "get_original_stdout()"

      * "args_from_interpreter_flags()"

      * "optim_args_from_interpreter_flags()"

      * "captured_stdin()"

      * "captured_stdout()"

      * "captured_stderr()"

      * "disable_faulthandler()"

      * "gc_collect()"

      * "disable_gc()"

      * "swap_attr()"

      * "swap_item()"

      * "flush_std_streams()"

      * "print_warning()"

      * "wait_process()"

      * "calcobjsize()"

      * "calcvobjsize()"

      * "checksizeof()"

      * "anticipate_failure()"

      * "system_must_validate_cert()"

      * "run_with_locale()"

      * "run_with_tz()"

      * "requires_freebsd_version()"

      * "requires_linux_version()"

      * "requires_mac_version()"

      * "requires_IEEE_754()"

      * "requires_zlib()"

      * "requires_gzip()"

      * "requires_bz2()"

      * "requires_lzma()"

      * "requires_resource()"

      * "requires_docstrings()"

      * "requires_limited_api()"

      * "cpython_only()"

      * "impl_detail()"

      * "no_tracing()"

      * "refcount_test()"

      * "bigmemtest()"

      * "bigaddrspacetest()"

      * "check_syntax_error()"

      * "open_urlresource()"

      * "reap_children()"

      * "get_attribute()"

      * "catch_unraisable_exception()"

      * "load_package_tests()"

      * "detect_api_mismatch()"

      * "patch()"

      * "run_in_subinterp()"

      * "check_free_after_iterating()"

      * "missing_compiler_executable()"

      * "check__all__()"

      * "skip_if_broken_multiprocessing_synchronize()"

      * "check_disallow_instantiation()"

      * "adjust_int_max_str_digits()"

      * "SuppressCrashReport"

      * "SaveSignals"

        * "save()"

        * "restore()"

      * "Matcher"

        * "matches()"

        * "match_value()"

    * "test.support.socket_helper" --- 소켓 테스트용 유틸리티

      * "IPV6_ENABLED"

      * "find_unused_port()"

      * "bind_port()"

      * "bind_unix_socket()"

      * "skip_unless_bind_unix_socket()"

      * "transient_internet()"

    * "test.support.script_helper" --- 파이썬 실행 테스트용 유틸리티

      * "interpreter_requires_environment()"

      * "run_python_until_end()"

      * "assert_python_ok()"

      * "assert_python_failure()"

      * "spawn_python()"

      * "kill_python()"

      * "make_script()"

      * "make_zip_script()"

      * "make_pkg()"

      * "make_zip_pkg()"

    * "test.support.bytecode_helper" --- 올바른 바이트 코드 생성 테스
      트를 위한 지원 도구

      * "BytecodeTestCase"

      * "get_disassembly_as_string()"

      * "assertInBytecode()"

      * "assertNotInBytecode()"

    * "test.support.threading_helper" --- Utilities for threading
      tests

      * "join_thread()"

      * "reap_threads()"

      * "start_threads()"

      * "threading_cleanup()"

      * "threading_setup()"

      * "wait_threads_exit()"

      * "catch_threading_exception()"

    * "test.support.os_helper" --- Utilities for os tests

      * "FS_NONASCII"

      * "SAVEDCWD"

      * "TESTFN"

      * "TESTFN_NONASCII"

      * "TESTFN_UNENCODABLE"

      * "TESTFN_UNDECODABLE"

      * "TESTFN_UNICODE"

      * "EnvironmentVarGuard"

      * "FakePath"

      * "set()"

      * "unset()"

      * "can_symlink()"

      * "can_xattr()"

      * "change_cwd()"

      * "create_empty_file()"

      * "fd_count()"

      * "fs_is_case_insensitive()"

      * "make_bad_fd()"

      * "rmdir()"

      * "rmtree()"

      * "skip_unless_symlink()"

      * "skip_unless_xattr()"

      * "temp_cwd()"

      * "temp_dir()"

      * "temp_umask()"

      * "unlink()"

    * "test.support.import_helper" --- Utilities for import tests

      * "forget()"

      * "import_fresh_module()"

      * "import_module()"

      * "modules_setup()"

      * "modules_cleanup()"

      * "unload()"

      * "make_legacy_pyc()"

      * "CleanImport"

      * "DirsOnSysPath"

    * "test.support.warnings_helper" --- Utilities for warnings tests

      * "ignore_warnings()"

      * "check_no_resource_warning()"

      * "check_syntax_warning()"

      * "check_warnings()"

      * "WarningsRecorder"

  * 디버깅과 프로파일링

    * 감사 이벤트 표

    * "bdb" --- Debugger framework

      * "BdbQuit"

      * "Breakpoint"

        * "deleteMe()"

        * "enable()"

        * "disable()"

        * "bpformat()"

        * "bpprint()"

        * "file"

        * "line"

        * "temporary"

        * "cond"

        * "funcname"

        * "enabled"

        * "bpbynumber"

        * "bplist"

        * "ignore"

        * "hits"

      * "Bdb"

        * "canonic()"

        * "reset()"

        * "trace_dispatch()"

        * "dispatch_line()"

        * "dispatch_call()"

        * "dispatch_return()"

        * "dispatch_exception()"

        * "is_skipped_line()"

        * "stop_here()"

        * "break_here()"

        * "break_anywhere()"

        * "user_call()"

        * "user_line()"

        * "user_return()"

        * "user_exception()"

        * "do_clear()"

        * "set_step()"

        * "set_next()"

        * "set_return()"

        * "set_until()"

        * "set_trace()"

        * "set_continue()"

        * "set_quit()"

        * "set_break()"

        * "clear_break()"

        * "clear_bpbynumber()"

        * "clear_all_file_breaks()"

        * "clear_all_breaks()"

        * "get_bpbynumber()"

        * "get_break()"

        * "get_breaks()"

        * "get_file_breaks()"

        * "get_all_breaks()"

        * "get_stack()"

        * "format_stack_entry()"

        * "run()"

        * "runeval()"

        * "runctx()"

        * "runcall()"

      * "checkfuncname()"

      * "effective()"

      * "set_trace()"

    * "faulthandler" --- Dump the Python traceback

      * 트레이스백 덤프하기

        * "dump_traceback()"

      * 결함 처리기 상태

        * "enable()"

        * "disable()"

        * "is_enabled()"

      * 시간 초과 후에 트레이스백 덤프하기

        * "dump_traceback_later()"

        * "cancel_dump_traceback_later()"

      * 사용자 시그널에 트레이스백 덤프하기

        * "register()"

        * "unregister()"

      * 파일 기술자 관련 문제

      * 예제

    * "pdb" --- 파이썬 디버거

      * "run()"

      * "runeval()"

      * "runcall()"

      * "set_trace()"

      * "post_mortem()"

      * "pm()"

      * "Pdb"

        * "run()"

        * "runeval()"

        * "runcall()"

        * "set_trace()"

      * 디버거 명령들

    * 파이썬 프로파일러

      * 프로파일러 소개

      * 즉석 사용자 설명서

      * "profile"과 "cProfile" 모듈 레퍼런스

        * "run()"

        * "runctx()"

        * "Profile"

          * "enable()"

          * "disable()"

          * "create_stats()"

          * "print_stats()"

          * "dump_stats()"

          * "run()"

          * "runctx()"

          * "runcall()"

      * "Stats" 클래스

        * "Stats"

          * "strip_dirs()"

          * "add()"

          * "dump_stats()"

          * "sort_stats()"

          * "reverse_order()"

          * "print_stats()"

          * "print_callers()"

          * "print_callees()"

          * "get_stats_profile()"

      * 결정론적 프로파일링이란 무엇입니까?

      * 한계

      * 보정

      * 사용자 정의 타이머 사용하기

    * "timeit" --- Measure execution time of small code snippets

      * 기본 예제

      * 파이썬 인터페이스

        * "timeit()"

        * "repeat()"

        * "default_timer()"

        * "Timer"

          * "timeit()"

          * "autorange()"

          * "repeat()"

          * "print_exc()"

      * 명령 줄 인터페이스

      * 예제

    * "trace" --- Trace or track Python statement execution

      * 명령 줄 사용법

        * 주요 옵션

        * 수정자

        * 필터

      * 프로그래밍 인터페이스

        * "Trace"

          * "run()"

          * "runctx()"

          * "runfunc()"

          * "results()"

        * "CoverageResults"

          * "update()"

          * "write_results()"

    * "tracemalloc" --- Trace memory allocations

      * 예

        * 상위 10개 표시

        * 차이 계산

        * 메모리 블록의 트레이스백 얻기

        * 예쁜 탑(top)

          * 모든 추적한 메모리 블록의 현재 및 최대 크기를 기록

      * API

        * 함수

          * "clear_traces()"

          * "get_object_traceback()"

          * "get_traceback_limit()"

          * "get_traced_memory()"

          * "reset_peak()"

          * "get_tracemalloc_memory()"

          * "is_tracing()"

          * "start()"

          * "stop()"

          * "take_snapshot()"

        * DomainFilter

          * "DomainFilter"

            * "inclusive"

            * "domain"

        * Filter

          * "Filter"

            * "domain"

            * "inclusive"

            * "lineno"

            * "filename_pattern"

            * "all_frames"

        * Frame

          * "Frame"

            * "filename"

            * "lineno"

        * Snapshot

          * "Snapshot"

            * "compare_to()"

            * "dump()"

            * "filter_traces()"

            * "load()"

            * "statistics()"

            * "traceback_limit"

            * "traces"

        * Statistic

          * "Statistic"

            * "count"

            * "size"

            * "traceback"

        * StatisticDiff

          * "StatisticDiff"

            * "count"

            * "count_diff"

            * "size"

            * "size_diff"

            * "traceback"

        * Trace

          * "Trace"

            * "domain"

            * "size"

            * "traceback"

        * Traceback

          * "Traceback"

            * "total_nframe"

            * "format()"

  * 소프트웨어 패키징 및 배포

    * "ensurepip" --- Bootstrapping the "pip" installer

      * 명령 줄 인터페이스

      * 모듈 API

        * "version()"

        * "bootstrap()"

    * "venv" --- Creation of virtual environments

      * 가상 환경 만들기

      * How venvs work

      * API

        * "EnvBuilder"

          * "create()"

          * "ensure_directories()"

          * "create_configuration()"

          * "setup_python()"

          * "setup_scripts()"

          * "upgrade_dependencies()"

          * "post_setup()"

          * "install_scripts()"

        * "create()"

      * "EnvBuilder" 확장 예제

    * "zipapp" --- Manage executable Python zip archives

      * 기본 예

      * 명령 줄 인터페이스

      * 파이썬 API

        * "create_archive()"

        * "get_interpreter()"

      * 예

      * 인터프리터 지정하기

      * zipapp으로 독립형 응용 프로그램 만들기

        * 경고

      * 파이썬 Zip 응용 프로그램 아카이브 형식

  * 파이썬 실행시간 서비스

    * "sys" --- System-specific parameters and functions

      * "abiflags"

      * "addaudithook()"

      * "argv"

      * "audit()"

      * "base_exec_prefix"

      * "base_prefix"

      * "byteorder"

      * "builtin_module_names"

      * "call_tracing()"

      * "copyright"

      * "_clear_type_cache()"

      * "_current_frames()"

      * "_current_exceptions()"

      * "breakpointhook()"

      * "_debugmallocstats()"

      * "dllhandle"

      * "displayhook()"

      * "dont_write_bytecode"

      * "_emscripten_info"

        * "emscripten_version"

        * "runtime"

        * "pthreads"

        * "shared_memory"

      * "pycache_prefix"

      * "excepthook()"

      * "__breakpointhook__"

      * "__displayhook__"

      * "__excepthook__"

      * "__unraisablehook__"

      * "exception()"

      * "exc_info()"

      * "exec_prefix"

      * "executable"

      * "exit()"

      * "flags"

        * "debug"

        * "inspect"

        * "interactive"

        * "isolated"

        * "optimize"

        * "dont_write_bytecode"

        * "no_user_site"

        * "no_site"

        * "ignore_environment"

        * "verbose"

        * "bytes_warning"

        * "quiet"

        * "hash_randomization"

        * "dev_mode"

        * "utf8_mode"

        * "safe_path"

        * "int_max_str_digits"

        * "warn_default_encoding"

      * "float_info"

        * "epsilon"

        * "dig"

        * "mant_dig"

        * "max"

        * "max_exp"

        * "max_10_exp"

        * "min"

        * "min_exp"

        * "min_10_exp"

        * "radix"

        * "rounds"

      * "float_repr_style"

      * "getallocatedblocks()"

      * "getunicodeinternedsize()"

      * "getandroidapilevel()"

      * "getdefaultencoding()"

      * "getdlopenflags()"

      * "getfilesystemencoding()"

      * "getfilesystemencodeerrors()"

      * "get_int_max_str_digits()"

      * "getrefcount()"

      * "getrecursionlimit()"

      * "getsizeof()"

      * "getswitchinterval()"

      * "_getframe()"

      * "_getframemodulename()"

      * "getobjects()"

      * "getprofile()"

      * "gettrace()"

      * "getwindowsversion()"

      * "get_asyncgen_hooks()"

      * "get_coroutine_origin_tracking_depth()"

      * "hash_info"

        * "width"

        * "modulus"

        * "inf"

        * "nan"

        * "imag"

        * "algorithm"

        * "hash_bits"

        * "seed_bits"

      * "hexversion"

      * "implementation"

      * "int_info"

        * "bits_per_digit"

        * "sizeof_digit"

        * "default_max_str_digits"

        * "str_digits_check_threshold"

      * "__interactivehook__"

      * "intern()"

      * "is_finalizing()"

      * "last_exc"

      * "last_type"

      * "last_value"

      * "last_traceback"

      * "maxsize"

      * "maxunicode"

      * "meta_path"

      * "modules"

      * "orig_argv"

      * "path"

      * "path_hooks"

      * "path_importer_cache"

      * "platform"

      * "platlibdir"

      * "prefix"

      * "ps1"

      * "ps2"

      * "setdlopenflags()"

      * "set_int_max_str_digits()"

      * "setprofile()"

      * "setrecursionlimit()"

      * "setswitchinterval()"

      * "settrace()"

      * "set_asyncgen_hooks()"

      * "set_coroutine_origin_tracking_depth()"

      * "activate_stack_trampoline()"

      * "deactivate_stack_trampoline()"

      * "is_stack_trampoline_active()"

      * "_enablelegacywindowsfsencoding()"

      * "stdin"

      * "stdout"

      * "stderr"

      * "__stdin__"

      * "__stdout__"

      * "__stderr__"

      * "stdlib_module_names"

      * "thread_info"

        * "name"

        * "lock"

        * "version"

      * "tracebacklimit"

      * "unraisablehook()"

      * "version"

      * "api_version"

      * "version_info"

      * "warnoptions"

      * "winver"

      * "_xoptions"

    * "sys.monitoring" --- Execution event monitoring

      * Tool identifiers

        * Registering and using tools

          * "use_tool_id()"

          * "free_tool_id()"

          * "get_tool()"

      * Events

        * Local events

        * Ancillary events

        * Other events

        * The STOP_ITERATION event

      * Turning events on and off

        * Setting events globally

          * "get_events()"

          * "set_events()"

        * Per code object events

          * "get_local_events()"

          * "set_local_events()"

        * Disabling events

          * "DISABLE"

          * "restart_events()"

      * Registering callback functions

        * "register_callback()"

        * Callback function arguments

          * "MISSING"

    * "sysconfig" --- Provide access to Python's configuration
      information

      * 구성 변수

        * "get_config_vars()"

        * "get_config_var()"

      * 설치 경로

      * User scheme

        * "posix_user"

        * "nt_user"

        * "osx_framework_user"

      * Home scheme

        * "posix_home"

      * Prefix scheme

        * "posix_prefix"

        * "nt"

      * Installation path functions

        * "get_scheme_names()"

        * "get_default_scheme()"

        * "get_preferred_scheme()"

        * "_get_preferred_schemes()"

        * "get_path_names()"

        * "get_path()"

        * "get_paths()"

      * 기타 함수

        * "get_python_version()"

        * "get_platform()"

        * "is_python_build()"

        * "parse_config_h()"

        * "get_config_h_filename()"

        * "get_makefile_filename()"

      * "sysconfig" 를 스크립트로 사용하기

    * "builtins" --- Built-in objects

    * "__main__" --- Top-level code environment

      * "__name__ == '__main__'"

        * What is the "top-level code environment"?

        * Idiomatic Usage

        * Packaging Considerations

      * "__main__.py" in Python Packages

        * Idiomatic Usage

      * "import __main__"

    * "warnings" --- Warning control

      * 경고 범주

      * 경고 필터

        * Repeated Warning Suppression Criteria

        * 경고 필터 설명

        * 기본 경고 필터

        * 기본 필터 재정의

      * 일시적인 경고 억제

      * 경고 테스트

      * 새 버전의 종속성에 대한 코드 갱신

      * 사용 가능한 함수

        * "warn()"

        * "warn_explicit()"

        * "showwarning()"

        * "formatwarning()"

        * "filterwarnings()"

        * "simplefilter()"

        * "resetwarnings()"

      * 사용 가능한 컨텍스트 관리자

        * "catch_warnings"

    * "dataclasses" --- Data Classes

      * Module contents

        * "dataclass()"

        * "field()"

        * "Field"

        * "fields()"

        * "asdict()"

        * "astuple()"

        * "make_dataclass()"

        * "replace()"

        * "is_dataclass()"

        * "MISSING"

        * "KW_ONLY"

        * "FrozenInstanceError"

      * 초기화 후처리

        * "__post_init__()"

      * 클래스 변수

      * 초기화 전용 변수

      * 고정 인스턴스

      * 계승

      * Re-ordering of keyword-only parameters in "__init__()"

      * 기본 팩토리 함수

      * 가변 기본값

      * Descriptor-typed fields

    * "contextlib" --- "with" 문 컨텍스트를 위한 유틸리티

      * 유틸리티

        * "AbstractContextManager"

        * "AbstractAsyncContextManager"

        * "contextmanager()"

        * "asynccontextmanager()"

        * "closing()"

        * "aclosing()"

        * "nullcontext()"

        * "suppress()"

        * "redirect_stdout()"

        * "redirect_stderr()"

        * "chdir()"

        * "ContextDecorator"

        * "AsyncContextDecorator"

        * "ExitStack"

          * "enter_context()"

          * "push()"

          * "callback()"

          * "pop_all()"

          * "close()"

        * "AsyncExitStack"

          * "enter_async_context()"

          * "push_async_exit()"

          * "push_async_callback()"

          * "aclose()"

      * 예제와 조리법

        * 일정하지 않은 수의 컨텍스트 관리자 지원

        * "__enter__" 메서드에서 발생하는 예외 잡기

        * "__enter__" 구현에서 정리하기

        * "try-finally"와 플래그 변수 사용 교체하기

        * 함수 데코레이터로 컨텍스트 관리자 사용하기

      * 일회용, 재사용 가능 및 재진입 가능 컨텍스트 관리자

        * 재진입 가능 컨텍스트 관리자

        * 재사용 가능 컨텍스트 관리자

    * "abc" --- Abstract Base Classes

      * "ABC"

      * "ABCMeta"

        * "register()"

        * "__subclasshook__()"

      * "abstractmethod()"

      * "abstractclassmethod()"

      * "abstractstaticmethod()"

      * "abstractproperty()"

      * "get_cache_token()"

      * "update_abstractmethods()"

    * "atexit" --- Exit handlers

      * "register()"

      * "unregister()"

      * "atexit" 예제

    * "traceback" --- Print or retrieve a stack traceback

      * Module-Level Functions

        * "print_tb()"

        * "print_exception()"

        * "print_exc()"

        * "print_last()"

        * "print_stack()"

        * "extract_tb()"

        * "extract_stack()"

        * "print_list()"

        * "format_list()"

        * "format_exception_only()"

        * "format_exception()"

        * "format_exc()"

        * "format_tb()"

        * "format_stack()"

        * "clear_frames()"

        * "walk_stack()"

        * "walk_tb()"

      * "TracebackException" Objects

        * "TracebackException"

          * "__cause__"

          * "__context__"

          * "exceptions"

          * "__suppress_context__"

          * "__notes__"

          * "stack"

          * "exc_type"

          * "filename"

          * "lineno"

          * "end_lineno"

          * "text"

          * "offset"

          * "end_offset"

          * "msg"

          * "from_exception()"

          * "print()"

          * "format()"

          * "format_exception_only()"

      * "StackSummary" Objects

        * "StackSummary"

          * "extract()"

          * "from_list()"

          * "format()"

          * "format_frame_summary()"

      * "FrameSummary" Objects

        * "FrameSummary"

          * "filename"

          * "lineno"

          * "name"

          * "line"

      * Examples of Using the Module-Level Functions

      * Examples of Using "TracebackException"

    * "__future__" --- Future statement definitions

      * Module Contents

        * "_Feature"

        * "getOptionalRelease()"

        * "getMandatoryRelease()"

        * "compiler_flag"

    * "gc" --- Garbage Collector interface

      * "enable()"

      * "disable()"

      * "isenabled()"

      * "collect()"

      * "set_debug()"

      * "get_debug()"

      * "get_objects()"

      * "get_stats()"

      * "set_threshold()"

      * "get_count()"

      * "get_threshold()"

      * "get_referrers()"

      * "get_referents()"

      * "is_tracked()"

      * "is_finalized()"

      * "freeze()"

      * "unfreeze()"

      * "get_freeze_count()"

      * "garbage"

      * "callbacks"

      * "DEBUG_STATS"

      * "DEBUG_COLLECTABLE"

      * "DEBUG_UNCOLLECTABLE"

      * "DEBUG_SAVEALL"

      * "DEBUG_LEAK"

    * "inspect" --- Inspect live objects

      * 형과 멤버

        * "getmembers()"

        * "getmembers_static()"

        * "getmodulename()"

        * "ismodule()"

        * "isclass()"

        * "ismethod()"

        * "isfunction()"

        * "isgeneratorfunction()"

        * "isgenerator()"

        * "iscoroutinefunction()"

        * "markcoroutinefunction()"

        * "iscoroutine()"

        * "isawaitable()"

        * "isasyncgenfunction()"

        * "isasyncgen()"

        * "istraceback()"

        * "isframe()"

        * "iscode()"

        * "isbuiltin()"

        * "ismethodwrapper()"

        * "isroutine()"

        * "isabstract()"

        * "ismethoddescriptor()"

        * "isdatadescriptor()"

        * "isgetsetdescriptor()"

        * "ismemberdescriptor()"

      * 소스 코드 가져오기

        * "getdoc()"

        * "getcomments()"

        * "getfile()"

        * "getmodule()"

        * "getsourcefile()"

        * "getsourcelines()"

        * "getsource()"

        * "cleandoc()"

      * Signature 객체로 콜러블 검사하기

        * "signature()"

        * "Signature"

          * "empty"

          * "parameters"

          * "return_annotation"

          * "bind()"

          * "bind_partial()"

          * "replace()"

          * "from_callable()"

        * "Parameter"

          * "empty"

          * "name"

          * "default"

          * "annotation"

          * "kind"

          * "description"

          * "replace()"

        * "BoundArguments"

          * "arguments"

          * "args"

          * "kwargs"

          * "signature"

          * "apply_defaults()"

      * 클래스와 함수

        * "getclasstree()"

        * "getfullargspec()"

        * "getargvalues()"

        * "formatargvalues()"

        * "getmro()"

        * "getcallargs()"

        * "getclosurevars()"

        * "unwrap()"

        * "get_annotations()"

      * 인터프리터 스택

        * "FrameInfo"

          * "frame"

          * "filename"

          * "lineno"

          * "function"

          * "code_context"

          * "index"

          * "positions"

        * "Traceback"

          * "filename"

          * "lineno"

          * "function"

          * "code_context"

          * "index"

          * "positions"

        * "getframeinfo()"

        * "getouterframes()"

        * "getinnerframes()"

        * "currentframe()"

        * "stack()"

        * "trace()"

      * 정적으로 어트리뷰트 가져오기

        * "getattr_static()"

      * Current State of Generators, Coroutines, and Asynchronous
        Generators

        * "getgeneratorstate()"

        * "getcoroutinestate()"

        * "getasyncgenstate()"

        * "getgeneratorlocals()"

        * "getcoroutinelocals()"

        * "getasyncgenlocals()"

      * 코드 객체 비트 플래그

        * "CO_OPTIMIZED"

        * "CO_NEWLOCALS"

        * "CO_VARARGS"

        * "CO_VARKEYWORDS"

        * "CO_NESTED"

        * "CO_GENERATOR"

        * "CO_COROUTINE"

        * "CO_ITERABLE_COROUTINE"

        * "CO_ASYNC_GENERATOR"

      * Buffer flags

        * "BufferFlags"

          * "SIMPLE"

          * "WRITABLE"

          * "FORMAT"

          * "ND"

          * "STRIDES"

          * "C_CONTIGUOUS"

          * "F_CONTIGUOUS"

          * "ANY_CONTIGUOUS"

          * "INDIRECT"

          * "CONTIG"

          * "CONTIG_RO"

          * "STRIDED"

          * "STRIDED_RO"

          * "RECORDS"

          * "RECORDS_RO"

          * "FULL"

          * "FULL_RO"

          * "READ"

          * "WRITE"

      * 명령 줄 인터페이스

    * "site" --- Site-specific configuration hook

      * "sitecustomize"

      * "usercustomize"

      * Readline 구성

      * 모듈 내용

        * "PREFIXES"

        * "ENABLE_USER_SITE"

        * "USER_SITE"

        * "USER_BASE"

        * "main()"

        * "addsitedir()"

        * "getsitepackages()"

        * "getuserbase()"

        * "getusersitepackages()"

      * 명령 줄 인터페이스

  * 사용자 정의 파이썬 인터프리터

    * "code" --- Interpreter base classes

      * "InteractiveInterpreter"

      * "InteractiveConsole"

      * "interact()"

      * "compile_command()"

      * 대화형 인터프리터 객체

        * "runsource()"

        * "runcode()"

        * "showsyntaxerror()"

        * "showtraceback()"

        * "write()"

      * 대화형 콘솔 객체

        * "interact()"

        * "push()"

        * "resetbuffer()"

        * "raw_input()"

    * "codeop" --- Compile Python code

      * "compile_command()"

      * "Compile"

      * "CommandCompiler"

  * 모듈 임포트 하기

    * "zipimport" --- Import modules from Zip archives

      * "ZipImportError"

      * zipimporter 객체

        * "zipimporter"

          * "create_module()"

          * "exec_module()"

          * "find_spec()"

          * "get_code()"

          * "get_data()"

          * "get_filename()"

          * "get_source()"

          * "is_package()"

          * "load_module()"

          * "invalidate_caches()"

          * "archive"

          * "prefix"

      * 예제

    * "pkgutil" --- Package extension utility

      * "ModuleInfo"

      * "extend_path()"

      * "find_loader()"

      * "get_importer()"

      * "get_loader()"

      * "iter_importers()"

      * "iter_modules()"

      * "walk_packages()"

      * "get_data()"

      * "resolve_name()"

    * "modulefinder" --- Find modules used by a script

      * "AddPackagePath()"

      * "ReplacePackage()"

      * "ModuleFinder"

        * "report()"

        * "run_script()"

        * "modules"

      * "ModuleFinder"의 사용 예

    * "runpy" --- Locating and executing Python modules

      * "run_module()"

      * "run_path()"

    * "importlib" --- "import"의 구현

      * 소개

      * 함수

        * "__import__()"

        * "import_module()"

        * "invalidate_caches()"

        * "reload()"

      * "importlib.abc" -- import와 관련된 추상 베이스 클래스

        * "MetaPathFinder"

          * "find_spec()"

          * "invalidate_caches()"

        * "PathEntryFinder"

          * "find_spec()"

          * "invalidate_caches()"

        * "Loader"

          * "create_module()"

          * "exec_module()"

          * "load_module()"

        * "ResourceLoader"

          * "get_data()"

        * "InspectLoader"

          * "get_code()"

          * "get_source()"

          * "is_package()"

          * "source_to_code()"

          * "exec_module()"

          * "load_module()"

        * "ExecutionLoader"

          * "get_filename()"

        * "FileLoader"

          * "name"

          * "path"

          * "load_module()"

          * "get_filename()"

          * "get_data()"

        * "SourceLoader"

          * "path_stats()"

          * "path_mtime()"

          * "set_data()"

          * "get_code()"

          * "exec_module()"

          * "load_module()"

          * "get_source()"

          * "is_package()"

        * "ResourceReader"

          * "open_resource()"

          * "resource_path()"

          * "is_resource()"

          * "contents()"

        * "Traversable"

          * "name"

          * "iterdir()"

          * "is_dir()"

          * "is_file()"

          * "joinpath()"

          * "__truediv__()"

          * "open()"

          * "read_bytes()"

          * "read_text()"

        * "TraversableResources"

          * "files()"

      * "importlib.machinery" -- 임포터와 경로 훅

        * "SOURCE_SUFFIXES"

        * "DEBUG_BYTECODE_SUFFIXES"

        * "OPTIMIZED_BYTECODE_SUFFIXES"

        * "BYTECODE_SUFFIXES"

        * "EXTENSION_SUFFIXES"

        * "all_suffixes()"

        * "BuiltinImporter"

        * "FrozenImporter"

        * "WindowsRegistryFinder"

        * "PathFinder"

          * "find_spec()"

          * "invalidate_caches()"

        * "FileFinder"

          * "path"

          * "find_spec()"

          * "invalidate_caches()"

          * "path_hook()"

        * "SourceFileLoader"

          * "name"

          * "path"

          * "is_package()"

          * "path_stats()"

          * "set_data()"

          * "load_module()"

        * "SourcelessFileLoader"

          * "name"

          * "path"

          * "is_package()"

          * "get_code()"

          * "get_source()"

          * "load_module()"

        * "ExtensionFileLoader"

          * "name"

          * "path"

          * "create_module()"

          * "exec_module()"

          * "is_package()"

          * "get_code()"

          * "get_source()"

          * "get_filename()"

        * "NamespaceLoader"

        * "ModuleSpec"

          * "name"

          * "loader"

          * "origin"

          * "submodule_search_locations"

          * "loader_state"

          * "cached"

          * "parent"

          * "has_location"

      * "importlib.util" -- 임포터를 위한 유틸리티 코드

        * "MAGIC_NUMBER"

        * "cache_from_source()"

        * "source_from_cache()"

        * "decode_source()"

        * "resolve_name()"

        * "find_spec()"

        * "module_from_spec()"

        * "spec_from_loader()"

        * "spec_from_file_location()"

        * "source_hash()"

        * "_incompatible_extension_module_restrictions()"

        * "LazyLoader"

          * "factory()"

      * 예

        * 프로그래밍 방식으로 임포트 하기

        * 모듈을 임포트 할 수 있는지 확인하기

        * 소스 파일을 직접 임포트 하기

        * Implementing lazy imports

        * 임포터 설정하기

        * "importlib.import_module()" 근사하기

    * "importlib.resources" -- Package resource reading, opening and
      access

      * "Anchor"

      * "files()"

      * "as_file()"

      * Deprecated functions

        * "Package"

        * "Resource"

        * "open_binary()"

        * "open_text()"

        * "read_binary()"

        * "read_text()"

        * "path()"

        * "is_resource()"

        * "contents()"

    * "importlib.resources.abc" -- Abstract base classes for resources

      * "ResourceReader"

        * "open_resource()"

        * "resource_path()"

        * "is_resource()"

        * "contents()"

      * "Traversable"

        * "name"

        * "iterdir()"

        * "is_dir()"

        * "is_file()"

        * "joinpath()"

        * "__truediv__()"

        * "open()"

        * "read_bytes()"

        * "read_text()"

      * "TraversableResources"

        * "files()"

    * "importlib.metadata" -- Accessing package metadata

      * 개요

        * "PackageNotFoundError"

      * 기능적 API

        * 진입 지점

          * "entry_points()"

          * "EntryPoints"

          * "EntryPoint"

        * 배포 메타데이터

          * "metadata()"

          * "PackageMetadata"

        * 배포 버전

          * "version()"

        * 배포 파일

          * "files()"

          * "PackagePath"

        * 배포 요구 사항

          * "requires()"

        * Mapping import to distribution packages

          * "packages_distributions()"

      * 배포

        * "distribution()"

        * "Distribution"

      * Distribution Discovery

      * 검색 알고리즘 확장하기

    * The initialization of the "sys.path" module search path

      * Virtual environments

      * _pth files

      * Embedded Python

  * 파이썬 언어 서비스

    * "ast" --- Abstract Syntax Trees

      * 추상 문법

      * 노드 클래스

        * "AST"

          * "_fields"

          * "lineno"

          * "col_offset"

          * "end_lineno"

          * "end_col_offset"

        * Root nodes

          * "Module"

          * "Expression"

          * "Interactive"

          * "FunctionType"

        * 리터럴

          * "Constant"

          * "FormattedValue"

          * "JoinedStr"

          * "List"

          * "Tuple"

          * "Set"

          * "Dict"

        * 변수

          * "Name"

          * "Load"

          * "Store"

          * "Del"

          * "Starred"

        * 표현식

          * "Expr"

          * "UnaryOp"

          * "UAdd"

          * "USub"

          * "Not"

          * "Invert"

          * "BinOp"

          * "Add"

          * "Sub"

          * "Mult"

          * "Div"

          * "FloorDiv"

          * "Mod"

          * "Pow"

          * "LShift"

          * "RShift"

          * "BitOr"

          * "BitXor"

          * "BitAnd"

          * "MatMult"

          * "BoolOp"

          * "And"

          * "Or"

          * "Compare"

          * "Eq"

          * "NotEq"

          * "Lt"

          * "LtE"

          * "Gt"

          * "GtE"

          * "Is"

          * "IsNot"

          * "In"

          * "NotIn"

          * "Call"

          * "keyword"

          * "IfExp"

          * "Attribute"

          * "NamedExpr"

          * 서브스크립팅

            * "Subscript"

            * "Slice"

          * 컴프리헨션

            * "ListComp"

            * "SetComp"

            * "GeneratorExp"

            * "DictComp"

            * "comprehension"

        * 문장

          * "Assign"

            * "type_comment"

          * "AnnAssign"

          * "AugAssign"

          * "Raise"

          * "Assert"

          * "Delete"

          * "Pass"

          * "TypeAlias"

          * 임포트

            * "Import"

            * "ImportFrom"

            * "alias"

        * 제어 흐름

          * "If"

          * "For"

            * "type_comment"

          * "While"

          * "Break"

          * "Continue"

          * "Try"

          * "TryStar"

          * "ExceptHandler"

          * "With"

            * "type_comment"

          * "withitem"

        * Pattern matching

          * "Match"

          * "match_case"

          * "MatchValue"

          * "MatchSingleton"

          * "MatchSequence"

          * "MatchStar"

          * "MatchMapping"

          * "MatchClass"

          * "MatchAs"

          * "MatchOr"

        * Type parameters

          * "TypeVar"

          * "ParamSpec"

          * "TypeVarTuple"

        * 함수와 클래스 정의

          * "FunctionDef"

            * "type_comment"

          * "Lambda"

          * "arguments"

          * "arg"

            * "type_comment"

          * "Return"

          * "Yield"

          * "YieldFrom"

          * "Global"

          * "Nonlocal"

          * "ClassDef"

        * Async와 await

          * "AsyncFunctionDef"

          * "Await"

          * "AsyncFor"

          * "AsyncWith"

      * "ast" 도우미

        * "parse()"

        * "unparse()"

        * "literal_eval()"

        * "get_docstring()"

        * "get_source_segment()"

        * "fix_missing_locations()"

        * "increment_lineno()"

        * "copy_location()"

        * "iter_fields()"

        * "iter_child_nodes()"

        * "walk()"

        * "NodeVisitor"

          * "visit()"

          * "generic_visit()"

          * "visit_Constant()"

        * "NodeTransformer"

        * "dump()"

      * 컴파일러 플래그

        * "PyCF_ALLOW_TOP_LEVEL_AWAIT"

        * "PyCF_ONLY_AST"

        * "PyCF_TYPE_COMMENTS"

      * 명령 줄 사용법

    * "symtable" --- Access to the compiler's symbol tables

      * 심볼 테이블 생성하기

        * "symtable()"

      * 심볼 테이블 검사하기

        * "SymbolTable"

          * "get_type()"

          * "get_id()"

          * "get_name()"

          * "get_lineno()"

          * "is_optimized()"

          * "is_nested()"

          * "has_children()"

          * "get_identifiers()"

          * "lookup()"

          * "get_symbols()"

          * "get_children()"

        * "Function"

          * "get_parameters()"

          * "get_locals()"

          * "get_globals()"

          * "get_nonlocals()"

          * "get_frees()"

        * "Class"

          * "get_methods()"

        * "Symbol"

          * "get_name()"

          * "is_referenced()"

          * "is_imported()"

          * "is_parameter()"

          * "is_global()"

          * "is_nonlocal()"

          * "is_declared_global()"

          * "is_local()"

          * "is_annotated()"

          * "is_free()"

          * "is_assigned()"

          * "is_namespace()"

          * "get_namespaces()"

          * "get_namespace()"

    * "token" --- Constants used with Python parse trees

      * "tok_name"

      * "ISTERMINAL()"

      * "ISNONTERMINAL()"

      * "ISEOF()"

      * "ENDMARKER"

      * "NAME"

      * "NUMBER"

      * "STRING"

      * "NEWLINE"

      * "INDENT"

      * "DEDENT"

      * "LPAR"

      * "RPAR"

      * "LSQB"

      * "RSQB"

      * "COLON"

      * "COMMA"

      * "SEMI"

      * "PLUS"

      * "MINUS"

      * "STAR"

      * "SLASH"

      * "VBAR"

      * "AMPER"

      * "LESS"

      * "GREATER"

      * "EQUAL"

      * "DOT"

      * "PERCENT"

      * "LBRACE"

      * "RBRACE"

      * "EQEQUAL"

      * "NOTEQUAL"

      * "LESSEQUAL"

      * "GREATEREQUAL"

      * "TILDE"

      * "CIRCUMFLEX"

      * "LEFTSHIFT"

      * "RIGHTSHIFT"

      * "DOUBLESTAR"

      * "PLUSEQUAL"

      * "MINEQUAL"

      * "STAREQUAL"

      * "SLASHEQUAL"

      * "PERCENTEQUAL"

      * "AMPEREQUAL"

      * "VBAREQUAL"

      * "CIRCUMFLEXEQUAL"

      * "LEFTSHIFTEQUAL"

      * "RIGHTSHIFTEQUAL"

      * "DOUBLESTAREQUAL"

      * "DOUBLESLASH"

      * "DOUBLESLASHEQUAL"

      * "AT"

      * "ATEQUAL"

      * "RARROW"

      * "ELLIPSIS"

      * "COLONEQUAL"

      * "EXCLAMATION"

      * "OP"

      * "AWAIT"

      * "ASYNC"

      * "TYPE_IGNORE"

      * "TYPE_COMMENT"

      * "SOFT_KEYWORD"

      * "FSTRING_START"

      * "FSTRING_MIDDLE"

      * "FSTRING_END"

      * "COMMENT"

      * "NL"

      * "ERRORTOKEN"

      * "N_TOKENS"

      * "NT_OFFSET"

      * "ENCODING"

      * "EXACT_TOKEN_TYPES"

    * "keyword" --- Testing for Python keywords

      * "iskeyword()"

      * "kwlist"

      * "issoftkeyword()"

      * "softkwlist"

    * "tokenize" --- Tokenizer for Python source

      * 입력 토큰화하기

        * "tokenize()"

        * "generate_tokens()"

        * "untokenize()"

        * "detect_encoding()"

        * "open()"

        * "TokenError"

      * 명령 줄 사용법

      * 예제

    * "tabnanny" --- Detection of ambiguous indentation

      * "check()"

      * "verbose"

      * "filename_only"

      * "NannyNag"

      * "process_tokens()"

    * "pyclbr" --- Python module browser support

      * "readmodule()"

      * "readmodule_ex()"

      * Function 객체

        * "Function"

          * "file"

          * "module"

          * "name"

          * "lineno"

          * "parent"

          * "children"

          * "is_async"

      * Class 객체

        * "Class"

          * "file"

          * "module"

          * "name"

          * "lineno"

          * "parent"

          * "children"

          * "super"

          * "methods"

    * "py_compile" --- Compile Python source files

      * "PyCompileError"

      * "compile()"

      * "PycInvalidationMode"

        * "TIMESTAMP"

        * "CHECKED_HASH"

        * "UNCHECKED_HASH"

      * Command-Line Interface

    * "compileall" --- Byte-compile Python libraries

      * 명령 줄 사용

      * 공용 함수

        * "compile_dir()"

        * "compile_file()"

        * "compile_path()"

    * "dis" --- Disassembler for Python bytecode

      * Command-line interface

      * 바이트 코드 분석

        * "Bytecode"

          * "from_traceback()"

          * "codeobj"

          * "first_line"

          * "dis()"

          * "info()"

      * 분석 함수

        * "code_info()"

        * "show_code()"

        * "dis()"

        * "distb()"

        * "disassemble()"

        * "disco()"

        * "get_instructions()"

        * "findlinestarts()"

        * "findlabels()"

        * "stack_effect()"

      * 파이썬 바이트 코드 명령어

        * "Instruction"

          * "opcode"

          * "opname"

          * "arg"

          * "argval"

          * "argrepr"

          * "offset"

          * "starts_line"

          * "is_jump_target"

          * "positions"

        * "Positions"

          * "lineno"

          * "end_lineno"

          * "col_offset"

          * "end_col_offset"

      * 옵코드 모음

        * "opname"

        * "opmap"

        * "cmp_op"

        * "hasarg"

        * "hasconst"

        * "hasfree"

        * "hasname"

        * "hasjrel"

        * "hasjabs"

        * "haslocal"

        * "hascompare"

        * "hasexc"

    * "pickletools" --- Tools for pickle developers

      * 명령 줄 사용법

        * 명령 줄 옵션

      * 프로그래밍 인터페이스

        * "dis()"

        * "genops()"

        * "optimize()"

  * MS 윈도우 특정 서비스

    * "msvcrt" --- Useful routines from the MS VC++ runtime

      * 파일 연산

        * "locking()"

        * "LK_LOCK"

        * "LK_RLCK"

        * "LK_NBLCK"

        * "LK_NBRLCK"

        * "LK_UNLCK"

        * "setmode()"

        * "open_osfhandle()"

        * "get_osfhandle()"

      * 콘솔 I/O

        * "kbhit()"

        * "getch()"

        * "getwch()"

        * "getche()"

        * "getwche()"

        * "putch()"

        * "putwch()"

        * "ungetch()"

        * "ungetwch()"

      * 기타 함수

        * "heapmin()"

        * "CRT_ASSEMBLY_VERSION"

        * "VC_ASSEMBLY_PUBLICKEYTOKEN"

        * "LIBRARIES_ASSEMBLY_NAME_PREFIX"

    * "winreg" --- Windows registry access

      * 함수

        * "CloseKey()"

        * "ConnectRegistry()"

        * "CreateKey()"

        * "CreateKeyEx()"

        * "DeleteKey()"

        * "DeleteKeyEx()"

        * "DeleteValue()"

        * "EnumKey()"

        * "EnumValue()"

        * "ExpandEnvironmentStrings()"

        * "FlushKey()"

        * "LoadKey()"

        * "OpenKey()"

        * "OpenKeyEx()"

        * "QueryInfoKey()"

        * "QueryValue()"

        * "QueryValueEx()"

        * "SaveKey()"

        * "SetValue()"

        * "SetValueEx()"

        * "DisableReflectionKey()"

        * "EnableReflectionKey()"

        * "QueryReflectionKey()"

      * 상수

        * HKEY_* 상수

          * "HKEY_CLASSES_ROOT"

          * "HKEY_CURRENT_USER"

          * "HKEY_LOCAL_MACHINE"

          * "HKEY_USERS"

          * "HKEY_PERFORMANCE_DATA"

          * "HKEY_CURRENT_CONFIG"

          * "HKEY_DYN_DATA"

        * 액세스 권한

          * "KEY_ALL_ACCESS"

          * "KEY_WRITE"

          * "KEY_READ"

          * "KEY_EXECUTE"

          * "KEY_QUERY_VALUE"

          * "KEY_SET_VALUE"

          * "KEY_CREATE_SUB_KEY"

          * "KEY_ENUMERATE_SUB_KEYS"

          * "KEY_NOTIFY"

          * "KEY_CREATE_LINK"

          * 64비트 특정

            * "KEY_WOW64_64KEY"

            * "KEY_WOW64_32KEY"

        * 값 형

          * "REG_BINARY"

          * "REG_DWORD"

          * "REG_DWORD_LITTLE_ENDIAN"

          * "REG_DWORD_BIG_ENDIAN"

          * "REG_EXPAND_SZ"

          * "REG_LINK"

          * "REG_MULTI_SZ"

          * "REG_NONE"

          * "REG_QWORD"

          * "REG_QWORD_LITTLE_ENDIAN"

          * "REG_RESOURCE_LIST"

          * "REG_FULL_RESOURCE_DESCRIPTOR"

          * "REG_RESOURCE_REQUIREMENTS_LIST"

          * "REG_SZ"

      * 레지스트리 핸들 객체

        * "Close()"

        * "Detach()"

        * "__enter__()"

        * "__exit__()"

    * "winsound" --- Sound-playing interface for Windows

      * "Beep()"

      * "PlaySound()"

      * "MessageBeep()"

      * "SND_FILENAME"

      * "SND_ALIAS"

      * "SND_LOOP"

      * "SND_MEMORY"

      * "SND_PURGE"

      * "SND_ASYNC"

      * "SND_NODEFAULT"

      * "SND_NOSTOP"

      * "SND_NOWAIT"

      * "MB_ICONASTERISK"

      * "MB_ICONEXCLAMATION"

      * "MB_ICONHAND"

      * "MB_ICONQUESTION"

      * "MB_OK"

  * 유닉스 특정 서비스

    * "posix" --- The most common POSIX system calls

      * 대용량 파일 지원

      * 주목할만한 모듈 내용

        * "environ"

    * "pwd" --- The password database

      * "getpwuid()"

      * "getpwnam()"

      * "getpwall()"

    * "grp" --- The group database

      * "getgrgid()"

      * "getgrnam()"

      * "getgrall()"

    * "termios" --- POSIX style tty control

      * "tcgetattr()"

      * "tcsetattr()"

        * "TCSANOW"

        * "TCSADRAIN"

        * "TCSAFLUSH"

      * "tcsendbreak()"

      * "tcdrain()"

      * "tcflush()"

      * "tcflow()"

      * "tcgetwinsize()"

      * "tcsetwinsize()"

      * 예제

    * "tty" --- Terminal control functions

      * "cfmakeraw()"

      * "cfmakecbreak()"

      * "setraw()"

      * "setcbreak()"

    * "pty" --- Pseudo-terminal utilities

      * "fork()"

      * "openpty()"

      * "spawn()"

      * 예제

    * "fcntl" --- The "fcntl" and "ioctl" system calls

      * "fcntl()"

      * "ioctl()"

      * "flock()"

      * "lockf()"

        * "LOCK_UN"

        * "LOCK_SH"

        * "LOCK_EX"

        * "LOCK_NB"

    * "resource" --- Resource usage information

      * "error"

      * 자원 제한

        * "RLIM_INFINITY"

        * "getrlimit()"

        * "setrlimit()"

        * "prlimit()"

        * "RLIMIT_CORE"

        * "RLIMIT_CPU"

        * "RLIMIT_FSIZE"

        * "RLIMIT_DATA"

        * "RLIMIT_STACK"

        * "RLIMIT_RSS"

        * "RLIMIT_NPROC"

        * "RLIMIT_NOFILE"

        * "RLIMIT_OFILE"

        * "RLIMIT_MEMLOCK"

        * "RLIMIT_VMEM"

        * "RLIMIT_AS"

        * "RLIMIT_MSGQUEUE"

        * "RLIMIT_NICE"

        * "RLIMIT_RTPRIO"

        * "RLIMIT_RTTIME"

        * "RLIMIT_SIGPENDING"

        * "RLIMIT_SBSIZE"

        * "RLIMIT_SWAP"

        * "RLIMIT_NPTS"

        * "RLIMIT_KQUEUES"

      * 자원 사용량

        * "getrusage()"

        * "getpagesize()"

        * "RUSAGE_SELF"

        * "RUSAGE_CHILDREN"

        * "RUSAGE_BOTH"

        * "RUSAGE_THREAD"

    * "syslog" --- Unix syslog library routines

      * "syslog()"

      * "openlog()"

      * "closelog()"

      * "setlogmask()"

      * 예제

        * 간단한 예제

  * Modules command-line interface (CLI)

  * 대체된 모듈

    * "aifc" --- AIFF와 AIFC 파일 읽고 쓰기

      * "open()"

      * "getnchannels()"

      * "getsampwidth()"

      * "getframerate()"

      * "getnframes()"

      * "getcomptype()"

      * "getcompname()"

      * "getparams()"

      * "getmarkers()"

      * "getmark()"

      * "readframes()"

      * "rewind()"

      * "setpos()"

      * "tell()"

      * "close()"

      * "aiff()"

      * "aifc()"

      * "setnchannels()"

      * "setsampwidth()"

      * "setframerate()"

      * "setnframes()"

      * "setcomptype()"

      * "setparams()"

      * "setmark()"

      * "writeframes()"

      * "writeframesraw()"

    * "audioop" --- Manipulate raw audio data

      * "error"

      * "add()"

      * "adpcm2lin()"

      * "alaw2lin()"

      * "avg()"

      * "avgpp()"

      * "bias()"

      * "byteswap()"

      * "cross()"

      * "findfactor()"

      * "findfit()"

      * "findmax()"

      * "getsample()"

      * "lin2adpcm()"

      * "lin2alaw()"

      * "lin2lin()"

      * "lin2ulaw()"

      * "max()"

      * "maxpp()"

      * "minmax()"

      * "mul()"

      * "ratecv()"

      * "reverse()"

      * "rms()"

      * "tomono()"

      * "tostereo()"

      * "ulaw2lin()"

    * "cgi" --- Common Gateway Interface support

      * Introduction

      * Using the cgi module

      * Higher Level Interface

        * "getfirst()"

        * "getlist()"

      * Functions

        * "parse()"

        * "parse_multipart()"

        * "parse_header()"

        * "test()"

        * "print_environ()"

        * "print_form()"

        * "print_directory()"

        * "print_environ_usage()"

      * Caring about security

      * Installing your CGI script on a Unix system

      * Testing your CGI script

      * Debugging CGI scripts

      * Common problems and solutions

    * "cgitb" --- CGI 스크립트를 위한 트레이스백 관리자

      * "enable()"

      * "text()"

      * "html()"

      * "handler()"

    * "chunk" --- IFF 청크된 데이터 읽기

      * "Chunk"

        * "getname()"

        * "getsize()"

        * "close()"

        * "isatty()"

        * "seek()"

        * "tell()"

        * "read()"

        * "skip()"

    * "crypt" --- 유닉스 비밀번호 확인 함수

      * 해싱 방법

        * "METHOD_SHA512"

        * "METHOD_SHA256"

        * "METHOD_BLOWFISH"

        * "METHOD_MD5"

        * "METHOD_CRYPT"

      * 모듈 어트리뷰트

        * "methods"

      * 모듈 함수

        * "crypt()"

        * "mksalt()"

      * 예제

    * "imghdr" --- 이미지 유형 판단

      * "what()"

      * "tests"

    * "mailcap" --- Mailcap 파일 처리

      * "findmatch()"

      * "getcaps()"

    * "msilib" --- Read and write Microsoft Installer files

      * "FCICreate()"

      * "UuidCreate()"

      * "OpenDatabase()"

      * "CreateRecord()"

      * "init_database()"

      * "add_data()"

      * "Binary"

      * "add_tables()"

      * "add_stream()"

      * "gen_uuid()"

      * Database Objects

        * "OpenView()"

        * "Commit()"

        * "GetSummaryInformation()"

        * "Close()"

      * View Objects

        * "Execute()"

        * "GetColumnInfo()"

        * "Fetch()"

        * "Modify()"

        * "Close()"

      * Summary Information Objects

        * "GetProperty()"

        * "GetPropertyCount()"

        * "SetProperty()"

        * "Persist()"

      * Record Objects

        * "GetFieldCount()"

        * "GetInteger()"

        * "GetString()"

        * "SetString()"

        * "SetStream()"

        * "SetInteger()"

        * "ClearData()"

      * Errors

      * CAB Objects

        * "CAB"

          * "append()"

          * "commit()"

      * Directory Objects

        * "Directory"

          * "start_component()"

          * "add_file()"

          * "glob()"

          * "remove_pyc()"

      * Features

        * "Feature"

          * "set_current()"

      * GUI classes

        * "Control"

          * "event()"

          * "mapping()"

          * "condition()"

        * "RadioButtonGroup"

          * "add()"

        * "Dialog"

          * "control()"

          * "text()"

          * "bitmap()"

          * "line()"

          * "pushbutton()"

          * "radiogroup()"

          * "checkbox()"

      * Precomputed tables

        * "schema"

        * "sequence"

        * "text"

    * "nis" --- Sun의 NIS(옐로 페이지)에 대한 인터페이스

      * "match()"

      * "cat()"

      * "maps()"

      * "get_default_domain()"

      * "error"

    * "nntplib" --- NNTP 프로토콜 클라이언트

      * "NNTP"

      * "NNTP_SSL"

      * "NNTPError"

        * "response"

      * "NNTPReplyError"

      * "NNTPTemporaryError"

      * "NNTPPermanentError"

      * "NNTPProtocolError"

      * "NNTPDataError"

      * NNTP 객체

        * 어트리뷰트

          * "nntp_version"

          * "nntp_implementation"

        * 메서드

          * "quit()"

          * "getwelcome()"

          * "getcapabilities()"

          * "login()"

          * "starttls()"

          * "newgroups()"

          * "newnews()"

          * "list()"

          * "descriptions()"

          * "description()"

          * "group()"

          * "over()"

          * "help()"

          * "stat()"

          * "next()"

          * "last()"

          * "article()"

          * "head()"

          * "body()"

          * "post()"

          * "ihave()"

          * "date()"

          * "slave()"

          * "set_debuglevel()"

          * "xhdr()"

          * "xover()"

      * 유틸리티 함수

        * "decode_header()"

    * "optparse" --- Parser for command line options

      * 배경

        * 용어

        * 옵션은 무엇을 위한 것입니까?

        * 위치 인자는 무엇을 위한 것입니까?

      * 자습서

        * 옵션 액션의 이해

        * store 액션

        * 불리언 (플래그) 옵션 처리하기

        * 다른 액션들

        * 기본값

        * 도움말 생성하기

          * 옵션 그룹화하기

            * "OptionGroup"

            * "get_option_group()"

        * 버전 문자열 인쇄하기

          * "print_version()"

          * "get_version()"

        * "optparse"가 에러를 처리하는 방법

        * 모두 합치기

      * 레퍼런스 지침서

        * 구문 분석기 만들기

          * "OptionParser"

        * 구문 분석기 채우기

        * 옵션 정의하기

          * "add_option()"

          * "Values"

        * 옵션 어트리뷰트

          * "Option"

          * "action"

          * "type"

          * "dest"

          * "default"

          * "nargs"

          * "const"

          * "choices"

          * "callback"

          * "callback_args"

          * "callback_kwargs"

          * "help"

          * "metavar"

        * 표준 옵션 액션

        * 표준 옵션 형

        * 인자 구문 분석하기

          * "parse_args()"

        * 옵션 구문 분석기를 조회하고 조작하기

          * "disable_interspersed_args()"

          * "enable_interspersed_args()"

          * "get_option()"

          * "has_option()"

          * "remove_option()"

        * 옵션 간의 충돌

        * 정리

        * 기타 메서드

          * "set_usage()"

          * "print_usage()"

          * "get_usage()"

          * "set_defaults()"

      * 옵션 콜백

        * 콜백 옵션 정의하기

        * 콜백이 호출되는 방법

        * 콜백에서 에러 발생시키기

        * 콜백 예제 1: 간단한 콜백

        * 콜백 예제 2: 옵션 순서 확인

        * 콜백 예제 3: 옵션 순서 확인 (일반화)

        * 콜백 예제 4: 임의 조건 확인

        * 콜백 예제 5: 고정 인자

        * 콜백 예제 6: 가변 인자

      * "optparse" 확장하기

        * 새로운 형 추가하기

          * "TYPES"

          * "TYPE_CHECKER"

        * 새로운 액션 추가하기

          * "ACTIONS"

          * "STORE_ACTIONS"

          * "TYPED_ACTIONS"

          * "ALWAYS_TYPED_ACTIONS"

      * Exceptions

        * "OptionError"

        * "OptionConflictError"

        * "OptionValueError"

        * "BadOptionError"

        * "AmbiguousOptionError"

    * "ossaudiodev" --- Access to OSS-compatible audio devices

      * "OSSAudioError"

      * "open()"

      * "openmixer()"

      * Audio Device Objects

        * "close()"

        * "fileno()"

        * "read()"

        * "write()"

        * "writeall()"

        * "nonblock()"

        * "getfmts()"

        * "setfmt()"

        * "channels()"

        * "speed()"

        * "sync()"

        * "reset()"

        * "post()"

        * "setparameters()"

        * "bufsize()"

        * "obufcount()"

        * "obuffree()"

        * "closed"

        * "name"

        * "mode"

      * Mixer Device Objects

        * "close()"

        * "fileno()"

        * "controls()"

        * "stereocontrols()"

        * "reccontrols()"

        * "get()"

        * "set()"

        * "get_recsrc()"

        * "set_recsrc()"

    * "pipes" --- 셸 파이프라인에 대한 인터페이스

      * "Template"

      * Template 객체

        * "reset()"

        * "clone()"

        * "debug()"

        * "append()"

        * "prepend()"

        * "open()"

        * "copy()"

    * "sndhdr" --- 음향 파일 유형 판단

      * "what()"

      * "whathdr()"

      * "tests"

    * "spwd" --- 섀도 암호 데이터베이스

      * "getspnam()"

      * "getspall()"

    * "sunau" --- Sun AU 파일 읽고 쓰기

      * "open()"

      * "Error"

      * "AUDIO_FILE_MAGIC"

      * "AUDIO_FILE_ENCODING_MULAW_8"

      * "AUDIO_FILE_ENCODING_LINEAR_8"

      * "AUDIO_FILE_ENCODING_LINEAR_16"

      * "AUDIO_FILE_ENCODING_LINEAR_24"

      * "AUDIO_FILE_ENCODING_LINEAR_32"

      * "AUDIO_FILE_ENCODING_ALAW_8"

      * "AUDIO_FILE_ENCODING_FLOAT"

      * "AUDIO_FILE_ENCODING_DOUBLE"

      * "AUDIO_FILE_ENCODING_ADPCM_G721"

      * "AUDIO_FILE_ENCODING_ADPCM_G722"

      * "AUDIO_FILE_ENCODING_ADPCM_G723_3"

      * "AUDIO_FILE_ENCODING_ADPCM_G723_5"

      * AU_read 객체

        * "close()"

        * "getnchannels()"

        * "getsampwidth()"

        * "getframerate()"

        * "getnframes()"

        * "getcomptype()"

        * "getcompname()"

        * "getparams()"

        * "readframes()"

        * "rewind()"

        * "setpos()"

        * "tell()"

        * "getmarkers()"

        * "getmark()"

      * AU_write 객체

        * "setnchannels()"

        * "setsampwidth()"

        * "setframerate()"

        * "setnframes()"

        * "setcomptype()"

        * "setparams()"

        * "tell()"

        * "writeframesraw()"

        * "writeframes()"

        * "close()"

    * "telnetlib" --- 텔넷 클라이언트

      * "Telnet"

      * 텔넷 객체

        * "read_until()"

        * "read_all()"

        * "read_some()"

        * "read_very_eager()"

        * "read_eager()"

        * "read_lazy()"

        * "read_very_lazy()"

        * "read_sb_data()"

        * "open()"

        * "msg()"

        * "set_debuglevel()"

        * "close()"

        * "get_socket()"

        * "fileno()"

        * "write()"

        * "interact()"

        * "mt_interact()"

        * "expect()"

        * "set_option_negotiation_callback()"

      * 텔넷 예제

    * "uu" --- uuencode 파일 인코딩과 디코딩

      * "encode()"

      * "decode()"

      * "Error"

    * "xdrlib" --- XDR 데이터 인코딩과 디코딩

      * "Packer"

      * "Unpacker"

      * Packer 객체

        * "get_buffer()"

        * "reset()"

        * "pack_float()"

        * "pack_double()"

        * "pack_fstring()"

        * "pack_fopaque()"

        * "pack_string()"

        * "pack_opaque()"

        * "pack_bytes()"

        * "pack_list()"

        * "pack_farray()"

        * "pack_array()"

      * Unpacker 객체

        * "reset()"

        * "get_position()"

        * "set_position()"

        * "get_buffer()"

        * "done()"

        * "unpack_float()"

        * "unpack_double()"

        * "unpack_fstring()"

        * "unpack_fopaque()"

        * "unpack_string()"

        * "unpack_opaque()"

        * "unpack_bytes()"

        * "unpack_list()"

        * "unpack_farray()"

        * "unpack_array()"

      * 예외

        * "Error"

        * "ConversionError"

  * Removed Modules

  * Security Considerations

* 파이썬 인터프리터 확장 및 내장

  * 권장 제삼자 도구

  * 제삼자 도구 없이 확장 만들기

    * 1. C나 C++로 파이썬 확장하기

      * 1.1. 간단한 예

      * 1.2. 막간극: 에러와 예외

      * 1.3. 예제로 돌아가기

      * 1.4. 모듈의 메서드 테이블과 초기화 함수

      * 1.5. 컴파일과 링크

      * 1.6. C에서 파이썬 함수 호출하기

      * 1.7. 확장 함수에서 매개 변수 추출하기

      * 1.8. 확장 함수를 위한 키워드 매개 변수

      * 1.9. 임의의 값을 구축하기

      * 1.10. 참조 횟수

        * 1.10.1. 파이썬에서 참조 횟수 세기

        * 1.10.2. 소유권 규칙

        * 1.10.3. 살얼음

        * 1.10.4. NULL 포인터

      * 1.11. C++로 확장 작성하기

      * 1.12. 확장 모듈을 위한 C API 제공하기

    * 2. 확장형 정의하기: 자습서

      * 2.1. 기초

      * 2.2. 기초 예제에 데이터와 메서드 추가하기

      * 2.3. 데이터 어트리뷰트를 더 세밀하게 제어하기

      * 2.4. 순환 가비지 수거 지원하기

      * 2.5. 다른 형의 서브 클래싱

    * 3. 확장형 정의하기: 여러 가지 주제

      * 3.1. 파이널리제이션과 할당 해제

      * 3.2. 객체 표현

      * 3.3. 어트리뷰트 관리

        * 3.3.1. 범용 어트리뷰트 관리

        * 3.3.2. 형별 어트리뷰트 관리

      * 3.4. 객체 비교

      * 3.5. 추상 프로토콜 지원

      * 3.6. 약한 참조 지원

      * 3.7. 추가 제안

    * 4. C와 C++ 확장 빌드하기

      * 4.1. Building C and C++ Extensions with setuptools

    * 5. 윈도우에서 C와 C++ 확장 빌드하기

      * 5.1. 요리책 접근법

      * 5.2. 유닉스와 윈도우의 차이점

      * 5.3. DLL을 실제로 사용하기

  * 더 큰 응용 프로그램에 CPython 런타임을 내장하기

    * 1. 다른 응용 프로그램에 파이썬 내장하기

      * 1.1. 매우 고수준의 내장

      * 1.2. 매우 고수준 내장을 넘어서: 개요

      * 1.3. 순수한 내장

      * 1.4. 내장된 파이썬을 확장하기

      * 1.5. C++로 파이썬 내장하기

      * 1.6. 유닉스 계열 시스템에서 컴파일과 링크하기

* 파이썬/C API 레퍼런스 설명서

  * 소개

    * 코딩 표준

    * 인클루드 파일

    * 유용한 매크로들

    * 객체, 형 그리고 참조 횟수

      * 참조 횟수

        * 참조 횟수 상세

      * 형

    * 예외

    * 파이썬 임베딩하기

    * 디버깅 빌드

  * C API Stability

    * Unstable C API

    * 안정적인 응용 프로그램 바이너리 인터페이스

      * Limited C API

      * Stable ABI

      * Limited API Scope and Performance

      * Limited API Caveats

    * Platform Considerations

    * Contents of Limited API

  * 매우 고수준 계층

  * 참조 횟수

  * 예외 처리

    * 인쇄와 지우기

    * 예외 발생시키기

    * 경고 발행하기

    * 에러 표시기 조회하기

    * 시그널 처리하기

    * 예외 클래스

    * 예외 객체

    * 유니코드 예외 객체

    * 재귀 제어

    * 표준 예외

    * 표준 경고 범주

  * 유틸리티

    * 운영 체제 유틸리티

    * 시스템 함수

    * 프로세스 제어

    * 모듈 임포트 하기

    * 데이터 마샬링 지원

    * 인자 구문 분석과 값 구축

      * 인자 구문 분석

        * 문자열과 버퍼

        * 숫자

        * 기타 객체

        * API 함수

      * 값 구축

    * 문자열 변환과 포매팅

    * PyHash API

    * 리플렉션

    * 코덱 등록소와 지원 함수

      * 코덱 조회 API

      * 유니코드 인코딩 에러 처리기용 등록소 API

    * Support for Perf Maps

  * 추상 객체 계층

    * 객체 프로토콜

    * 호출 프로토콜

      * *tp_call* 프로토콜

      * 벡터콜(Vectorcall) 프로토콜

        * 재귀 제어

        * 벡터콜 지원 API

      * 객체 호출 API

      * 호출 지원 API

    * 숫자 프로토콜

    * 시퀀스 프로토콜

    * 매핑 프로토콜

    * 이터레이터 프로토콜

    * 버퍼 프로토콜

      * 버퍼 구조체

      * 버퍼 요청 유형

        * 요청 독립적 필드

        * readonly, format

        * shape, strides, suboffsets

        * 연속성 요청

        * 복합 요청

      * 복잡한 배열

        * NumPy-스타일: shape과 strides

        * PIL-스타일: shape, strides 및 suboffsets

      * 버퍼 관련 함수

    * 낡은 버퍼 프로토콜

  * 구상 객체 계층

    * 기본 객체

      * 형 객체

        * 힙에 할당된 형 만들기

      * "None" 객체

    * 숫자 객체

      * 정수 객체

      * 불리언 객체

      * Floating-Point Objects

        * Pack and Unpack functions

          * Pack functions

          * Unpack functions

      * 복소수 객체

        * C 구조체로서의 복소수

        * 파이썬 객체로서의 복소수

    * 시퀀스 객체

      * 바이트열 객체

      * 바이트 배열 객체

        * 형 검사 매크로

        * 직접 API 함수

        * 매크로

      * 유니코드 객체와 코덱

        * 유니코드 객체

          * 유니코드 형

          * 유니코드 문자 속성

          * 유니코드 문자열 생성과 액세스

          * 로케일 인코딩

          * 파일 시스템 인코딩

          * wchar_t 지원

        * 내장 코덱

          * 일반 코덱

          * UTF-8 코덱

          * UTF-32 코덱

          * UTF-16 코덱

          * UTF-7 코덱

          * 유니코드 이스케이프 코덱

          * 원시 유니코드 이스케이프 코덱

          * Latin-1 코덱

          * ASCII 코덱

          * 문자 맵 코덱

          * 윈도우 용 MBCS 코덱

          * 메서드와 슬롯

        * 메서드와 슬롯 함수

      * 튜플 객체

      * 구조체 시퀀스 객체

      * 리스트 객체

    * 컨테이너 객체

      * 딕셔너리 객체

      * 집합 객체

    * 함수 객체

      * 함수 객체

      * 인스턴스 메서드 객체

      * 메서드 객체

      * 셀 객체

      * 코드 객체

      * Extra information

    * 기타 객체

      * 파일 객체

      * 모듈 객체

        * C 모듈 초기화

          * 단단계 초기화

          * 다단계 초기화

          * 저수준 모듈 생성 함수

          * 지원 함수

        * 모듈 조회

      * 이터레이터 객체

      * 디스크립터 객체

      * 슬라이스 객체

        * Ellipsis 객체

      * MemoryView 객체

      * 약한 참조 객체

      * 캡슐

      * Frame Objects

        * Internal Frames

      * 제너레이터 객체

      * 코루틴 객체

      * 컨텍스트 변수 객체

      * DateTime 객체

      * Objects for Type Hinting

  * 초기화, 파이널리제이션 및 스레드

    * 파이썬 초기화 전

    * 전역 구성 변수

    * 인터프리터 초기화와 파이널리제이션

    * 프로세스 전체 매개 변수

    * 스레드 상태와 전역 인터프리터 록

      * 확장 코드에서 GIL 해제하기

      * 파이썬이 만들지 않은 스레드

      * fork()에 대한 주의 사항

      * 고수준 API

      * 저수준 API

    * 서브 인터프리터 지원

      * A Per-Interpreter GIL

      * 버그와 주의 사항

    * 비동기 알림

    * 프로파일링과 추적

    * 고급 디버거 지원

    * 스레드 로컬 저장소 지원

      * 스레드별 저장소 (TSS - Thread Specific Storage) API

        * 동적 할당

        * 메서드

      * 스레드 로컬 저장소 (TLS) API

  * 파이썬 초기화 구성

    * Example

    * PyWideStringList

    * PyStatus

    * PyPreConfig

    * Preinitialize Python with PyPreConfig

    * PyConfig

    * PyConfig를 사용한 초기화

    * 격리된 구성

    * 파이썬 구성

    * Python Path Configuration

    * Py_RunMain()

    * Py_GetArgcArgv()

    * 다단계 초기화 비공개 잠정적 API

  * 메모리 관리

    * 개요

    * Allocator Domains

    * 원시 메모리 인터페이스

    * 메모리 인터페이스

    * 객체 할당자

    * 기본 메모리 할당자

    * 메모리 할당자 사용자 정의

    * Debug hooks on the Python memory allocators

    * pymalloc 할당자

      * pymalloc 아레나 할당자 사용자 정의

    * tracemalloc C API

    * 예

  * 객체 구현 지원

    * 힙에 객체 할당하기

    * 공통 객체 구조체

      * 기본 객체 형과 매크로

      * 함수와 메서드 구현

      * 확장형의 어트리뷰트 액세스

        * Member flags

        * Member types

        * Defining Getters and Setters

    * 형 객체

      * 간략 참조

        * "tp 슬롯"

        * 서브 슬롯

        * 슬롯 typedef

      * PyTypeObject 정의

      * PyObject 슬롯

      * PyVarObject 슬롯

      * PyTypeObject 슬롯

      * Static Types

      * 힙 형

      * 숫자 객체 구조체

      * 매핑 객체 구조체

      * 시퀀스 객체 구조체

      * 버퍼 객체 구조체

      * 비동기 객체 구조체

      * 슬롯 형 typedef

      * 예

    * 순환 가비지 수집 지원

      * Controlling the Garbage Collector State

      * Querying Garbage Collector State

  * API와 ABI 버전 붙이기

* 파이썬 모듈 설치하기

  * 핵심 용어

  * 기본 사용법

  * 어떻게 ...?

    * ... 파이썬 3.4 이전 버전의 파이썬에서 "pip" 를 설치합니까?

    * ... 현재 사용자만을 위해 패키지를 설치합니까?

    * ... 과학 계산용 파이썬 패키지를 설치합니까?

    * ... 병렬로 설치된 여러 버전의 파이썬으로 작업합니까?

  * 흔히 만나는 설치 문제

    * 리눅스에 시스템 파이썬 설치하기

    * Pip가 설치되지 않았습니다.

    * 바이너리 확장 설치하기

* 파이썬 HOWTO

* 파이썬 자주 나오는 질문들

  * 일반적인 파이썬 FAQ

    * 일반적인 정보

    * 현실 속의 파이썬

  * 프로그래밍 FAQ

    * 일반적인 질문

    * 핵심 언어

    * 숫자와 문자열

    * 성능

    * 시퀀스 (튜플/리스트)

    * 객체

    * 모듈

  * 설계와 역사 FAQ

    * 파이썬은 왜 문장의 그룹화에 들여쓰기를 사용합니까?

    * 간단한 산술 연산으로 이상한 결과가 나오는 이유는 무엇입니까?

    * 부동 소수점 계산이 왜 그렇게 부정확합니까?

    * 파이썬 문자열이 불변인 이유는 무엇입니까?

    * 메서드 정의와 호출에서 'self'를 명시적으로 사용해야 하는 이유는
      무엇입니까?

    * 표현식에서 대입을 사용할 수 없는 이유는 무엇입니까?

    * 파이썬은 왜 일부 기능(예를 들어 list.index())에는 메서드를 사용
      하고 다른 기능(예를 들어 len(list))에는 함수를 사용합니까?

    * join()이 리스트나 튜플 메서드가 아니라 문자열 메서드인 이유는 무
      엇입니까?

    * 예외는 얼마나 빠릅니까?

    * 파이썬에 switch 나 case 문이 없는 이유는 무엇입니까?

    * OS별 스레드 구현에 의존하는 대신 인터프리터에서 스레드를 에뮬레
      이션할 수 없습니까?

    * 람다 표현식이 문장을 포함할 수 없는 이유는 무엇입니까?

    * 파이썬을 기계 코드, C 또는 다른 언어로 컴파일 할 수 있습니까?

    * 파이썬은 메모리를 어떻게 관리합니까?

    * CPython이 더 전통적인 가비지 수거 체계를 사용하지 않는 이유는 무
      엇입니까?

    * CPython이 종료될 때 모든 메모리가 해제되지 않는 이유는 무엇입니
      까?

    * 별도의 튜플과 리스트 데이터형이 있는 이유는 무엇입니까?

    * CPython에서 리스트는 어떻게 구현됩니까?

    * CPython에서 딕셔너리는 어떻게 구현됩니까?

    * 딕셔너리 키가 불변이어야 하는 이유는 무엇입니까?

    * list.sort()가 정렬된 리스트를 반환하지 않는 이유는 무엇입니까?

    * 파이썬에서 인터페이스 명세를 어떻게 지정하고 강제합니까?

    * goto가 없는 이유는 무엇입니까?

    * 날 문자열(r-strings)이 역 슬래시로 끝날 수 없는 이유는 무엇입니
      까?

    * 왜 파이썬에는 어트리뷰트 대입을 위한 "with" 문이 없습니까?

    * Why don't generators support the with statement?

    * if/while/def/class 문에 콜론이 필요한 이유는 무엇입니까?

    * 파이썬은 왜 리스트와 튜플 끝에 쉼표를 허용합니까?

  * 라이브러리와 확장 FAQ

    * 일반 라이브러리 관련 질문

    * 일반적인 작업

    * 스레드

    * 입력과 출력

    * 네트워크/인터넷 프로그래밍

    * 데이터베이스

    * 수학과 숫자

  * 확장/내장 FAQ

    * C로 나만의 함수를 만들 수 있습니까?

    * C++로 나만의 함수를 만들 수 있습니까?

    * C를 쓰는 것은 어렵습니다; 대안이 있습니까?

    * C에서 임의의 파이썬 문장을 어떻게 실행할 수 있습니까?

    * C에서 임의의 파이썬 표현식을 어떻게 평가할 수 있습니까?

    * 파이썬 객체에서 C값을 어떻게 추출합니까?

    * Py_BuildValue()를 사용하여 임의 길이의 튜플을 만드는 방법은 무엇
      입니까?

    * C에서 객체의 메서드를 어떻게 호출합니까?

    * PyErr_Print()의 출력(또는 stdout/stderr로 인쇄되는 모든 것)을 어
      떻게 잡습니까?

    * C에서 파이썬으로 작성된 모듈에 어떻게 액세스합니까?

    * 파이썬에서 C++ 객체에 어떻게 인터페이스 합니까?

    * Setup 파일을 사용하여 모듈을 추가했는데 make가 실패합니다; 왜 그
      렇습니까?

    * 확장을 어떻게 디버깅합니까?

    * 리눅스 시스템에서 파이썬 모듈을 컴파일하고 싶지만, 일부 파일이
      없습니다. 왜 그렇습니까?

    * "잘못된 입력"과 "불완전한 입력"을 어떻게 구별할 수 있습니까?

    * 정의되지 않은 g++ 기호 __builtin_new나 __pure_virtual을 어떻게
      찾을 수 있습니까?

    * 일부 메서드는 C로 구현되고 그 밖의 것은 파이썬으로 구현된 (예를
      들어 상속을 통해) 객체 클래스를 만들 수 있습니까?

  * 윈도우 파이썬 FAQ

    * 윈도우에서 파이썬 프로그램을 실행하려면 어떻게 해야 합니까?

    * 파이썬 스크립트 실행 파일로 만들려면 어떻게 해야 합니까?

    * 왜 때때로 파이썬은 시작하는 데 시간이 오래 걸립니까?

    * 파이썬 스크립트에서 실행 파일을 만드는 방법은 무엇입니까?

    * "*.pyd" 파일은 DLL과 동일합니까?

    * 윈도우 응용프로그램에 파이썬을 포함하려면 어떻게 해야 합니까?

    * 편집기가 내 파이썬 소스에 탭을 삽입하지 않도록 하려면 어떻게 해
      야 합니까?

    * 블로킹 없이 키 입력을 확인하려면 어떻게 해야 합니까?

    * How do I solve the missing api-ms-win-crt-runtime-l1-1-0.dll
      error?

  * 그래픽 사용자 인터페이스 FAQ

    * 일반적인 GUI 질문

    * What GUI toolkits exist for Python?

    * Tkinter 질문

  * "왜 내 컴퓨터에 파이썬이 설치되어 있습니까?" FAQ

    * 파이썬이 무엇입니까?

    * 내 컴퓨터에 파이썬이 설치된 이유는 무엇입니까?

    * 파이썬을 삭제할 수 있습니까?

* Deprecations

  * Pending Removal in Python 3.13

  * Pending Removal in Python 3.14

  * Pending Removal in Python 3.15

  * Pending Removal in Python 3.16

  * Pending Removal in Future Versions

  * C API Deprecations

    * Pending Removal in Python 3.14

    * Pending Removal in Python 3.15

    * Pending Removal in Future Versions

* 용어집

* 이 설명서에 관하여

  * 파이썬 설명서의 공헌자들

* 버그 다루기

  * 설명서 버그

  * 파이썬 문제 추적기 사용하기

  * 파이썬에 직접 이바지하기 입문

* 저작권

* 역사와 라이센스

  * 소프트웨어의 역사

  * 파이썬에 액세스하거나 사용하기 위한 이용 약관

    * PSF LICENSE AGREEMENT FOR PYTHON 3.12.8

    * BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0

    * CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1

    * CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2

    * ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON 3.12.8
      DOCUMENTATION

  * 포함된 소프트웨어에 대한 라이센스 및 승인

    * 메르센 트위스터

    * 소켓

    * 비동기 소켓 서비스

    * 쿠키 관리

    * 실행 추적

    * UUencode 및 UUdecode 함수

    * XML 원격 프로시저 호출

    * test_epoll

    * Select kqueue

    * SipHash24

    * strtod 와 dtoa

    * OpenSSL

    * expat

    * libffi

    * zlib

    * cfuhash

    * libmpdec

    * W3C C14N 테스트 스위트

    * Audioop

    * asyncio
