documentation.HELP! Python 3.5 Documentation

13. Data Compression and Archiving

Python 3.5

previous page next page

Navigation

  • index
  • modules |
  • next |
  • previous |
  • Python »
  • 3.5.0rc3 Documentation »
  • The Python Standard Library »

13. Data Compression and Archiving

The modules described in this chapter support data compression with the zlib, gzip, bzip2 and lzma algorithms, and the creation of ZIP- and tar-format archives. See also Archiving operations provided by the shutil module.

  • 13.1. zlib — Compression compatible with gzip
  • 13.2. gzip — Support for gzip files
    • 13.2.1. Examples of usage
  • 13.3. bz2 — Support for bzip2 compression
    • 13.3.1. (De)compression of files
    • 13.3.2. Incremental (de)compression
    • 13.3.3. One-shot (de)compression
  • 13.4. lzma — Compression using the LZMA algorithm
    • 13.4.1. Reading and writing compressed files
    • 13.4.2. Compressing and decompressing data in memory
    • 13.4.3. Miscellaneous
    • 13.4.4. Specifying custom filter chains
    • 13.4.5. Examples
  • 13.5. zipfile — Work with ZIP archives
    • 13.5.1. ZipFile Objects
    • 13.5.2. PyZipFile Objects
    • 13.5.3. ZipInfo Objects
  • 13.6. tarfile — Read and write tar archive files
    • 13.6.1. TarFile Objects
    • 13.6.2. TarInfo Objects
    • 13.6.3. Command Line Interface
      • 13.6.3.1. Command line options
    • 13.6.4. Examples
    • 13.6.5. Supported tar formats
    • 13.6.6. Unicode issues

Navigation

  • index
  • modules |
  • next |
  • previous |
  • Python »
  • 3.5.0rc3 Documentation »
  • The Python Standard Library »
© Copyright 1990-2015, Python Software Foundation.
The Python Software Foundation is a non-profit corporation. Please donate.
Last updated on Sep 06, 2015. Found a bug?
Created using Sphinx 1.3.1.
previous page start next page

Menu

  • Homepage

Table of contents

  • 3.5.0rc3 Documentation
  • Python Module Index
  • What's New in Python
    • What's New In Python 3.5
      • Summary -- Release highlights
        • PEP 492 - Coroutines with async and await syntax
        • PEP 461 - Formatting support for bytes and bytearray
        • PEP 465 - A dedicated infix operator for matrix multiplication
        • PEP 448 - Additional Unpacking Generalizations
        • PEP 484 - Type Hints
        • PEP 471 - os.scandir() function -- a better and faster directory iterator
        • PEP 475: Retry system calls failing with EINTR
        • PEP 479: Change StopIteration handling inside generators
        • PEP 486: Make the Python Launcher aware of virtual environments
        • PEP 488: Elimination of PYO files
        • PEP 489: Multi-phase extension module initialization
        • PEP 485: A function for testing approximate equality
      • Other Language Changes
      • New Modules
        • zipapp
      • Improved Modules
        • argparse
        • cgi
        • cmath
        • code
        • collections
        • compileall
        • contextlib
        • curses
        • difflib
        • distutils
        • doctest
        • email
        • glob
        • idlelib and IDLE
        • imaplib
        • imghdr
        • importlib
        • inspect
        • ipaddress
        • json
        • math
        • os
        • os.path
        • pickle
        • poplib
        • re
        • shutil
        • signal
        • smtpd
        • smtplib
        • sndhdr
        • ssl
        • socket
        • subprocess
        • sys
        • sysconfig
        • tarfile
        • time
        • tkinter
        • types
        • urllib
        • unicodedata
        • wsgiref
        • xmlrpc
        • xml.sax
        • faulthandler
        • zipfile
      • Optimizations
      • Build and C API Changes
      • Deprecated
        • New Keywords
        • Unsupported Operating Systems
        • Deprecated Python modules, functions and methods
        • Deprecated functions and types of the C API
        • Deprecated features
      • Removed
        • API and Feature Removals
      • Porting to Python 3.5
        • Changes in the Python API
        • Changes in the C API
    • 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
        • PEP 434: IDLE Enhancement Exception for All Branches
        • PEP 466: Network Security Enhancements for Python 2.7
      • 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 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 alpha 2
        • Core and Builtins
        • Library
        • Build
        • C API
        • Windows
      • Python 3.5 alpha 1
        • Core and Builtins
        • Library
        • IDLE
        • Build
        • C API
        • Documentation
        • Tests
        • Tools/Demos
        • Windows
      • Python 3.4.0
        • Library
        • Documentation
      • Python 3.4.0 release candidate 3
        • Core and Builtins
        • Library
        • Build
      • Python 3.4.0 release candidate 2
        • Core and Builtins
        • Library
        • Build
      • Python 3.4.0 release candidate 1
        • Core and Builtins
        • Library
        • IDLE
        • Tests
        • Tools/Demos
        • Build
        • C-API
        • Documentation
      • Python 3.4.0 Beta 3
        • Core and Builtins
        • Library
        • IDLE
        • Tests
        • Tools/Demos
        • Build
      • Python 3.4.0 Beta 2
        • Core and Builtins
        • Library
        • IDLE
        • Tests
        • Build
        • Documentation
        • Tools/Demos
      • Python 3.4.0 Beta 1
        • Core and Builtins
        • Library
        • Tests
        • Documentation
        • Build
        • Tools/Demos
      • Python 3.4.0 Alpha 4
        • Core and Builtins
        • Library
        • C API
        • Tests
        • Documentation
        • Build
      • Python 3.4.0 Alpha 3
        • Core and Builtins
        • Library
        • Tests
        • IDLE
        • Documentation
        • Build
        • Tools/Demos
      • Python 3.4.0 Alpha 2
        • Core and Builtins
        • Library
        • Tests
        • IDLE
        • Documentation
        • Build
        • Tools/Demos
      • Python 3.4.0 Alpha 1
        • Core and Builtins
        • Library
        • IDLE
        • Tests
        • Build
        • C-API
        • Documentation
        • Tools/Demos
        • Windows
  • The Python Tutorial
    • Whetting Your Appetite
    • Using the Python Interpreter
      • Invoking the Interpreter
        • Argument Passing
        • Interactive Mode
      • The Interpreter and Its Environment
        • Source Code Encoding
    • An Informal Introduction to Python
      • Using Python as a Calculator
        • Numbers
        • Strings
        • Lists
      • First Steps Towards Programming
    • More Control Flow Tools
      • if Statements
      • for Statements
      • The range() Function
      • break and continue Statements, and else Clauses on Loops
      • pass Statements
      • Defining Functions
      • More on Defining Functions
        • Default Argument Values
        • Keyword Arguments
        • Arbitrary Argument Lists
        • Unpacking Argument Lists
        • Lambda Expressions
        • Documentation Strings
        • Function Annotations
      • Intermezzo: Coding Style
    • Data Structures
      • More on Lists
        • Using Lists as Stacks
        • Using Lists as Queues
        • List Comprehensions
        • Nested List Comprehensions
      • The del statement
      • Tuples and Sequences
      • Sets
      • Dictionaries
      • Looping Techniques
      • More on Conditions
      • Comparing Sequences and Other Types
    • Modules
      • More on Modules
        • Executing modules as scripts
        • The Module Search Path
        • "Compiled" Python files
      • Standard Modules
      • The dir() Function
      • Packages
        • Importing * From a Package
        • Intra-package References
        • Packages in Multiple Directories
    • Input and Output
      • Fancier Output Formatting
        • Old string formatting
      • Reading and Writing Files
        • Methods of File Objects
        • Saving structured data with json
    • Errors and Exceptions
      • Syntax Errors
      • Exceptions
      • Handling Exceptions
      • Raising Exceptions
      • User-defined Exceptions
      • Defining Clean-up Actions
      • Predefined Clean-up Actions
    • Classes
      • A Word About Names and Objects
      • Python Scopes and Namespaces
        • Scopes and Namespaces Example
      • A First Look at Classes
        • Class Definition Syntax
        • Class Objects
        • Instance Objects
        • Method Objects
        • Class and Instance Variables
      • Random Remarks
      • Inheritance
        • Multiple Inheritance
      • Private Variables
      • Odds and Ends
      • Exceptions Are Classes Too
      • Iterators
      • Generators
      • Generator Expressions
    • Brief Tour of the Standard Library
      • Operating System Interface
      • File Wildcards
      • Command Line Arguments
      • Error Output Redirection and Program Termination
      • String Pattern Matching
      • Mathematics
      • Internet Access
      • Dates and Times
      • Data Compression
      • Performance Measurement
      • Quality Control
      • Batteries Included
    • Brief Tour of the Standard Library -- Part II
      • Output Formatting
      • Templating
      • Working with Binary Data Record Layouts
      • Multi-threading
      • Logging
      • Weak References
      • Tools for Working with Lists
      • Decimal Floating Point Arithmetic
    • Virtual Environments and Packages
      • Introduction
      • Creating Virtual Environments
      • Managing Packages with pip
    • What Now?
    • Interactive Input Editing and History Substitution
      • Tab Completion and History Editing
      • Alternatives to the Interactive Interpreter
    • Floating Point Arithmetic: Issues and Limitations
      • Representation Error
    • Appendix
      • Interactive Mode
        • Error Handling
        • Executable Python Scripts
        • The Interactive Startup File
        • The Customization Modules
  • Python Setup and Usage
    • Command line and environment
      • Command line
        • Interface options
        • Generic options
        • Miscellaneous options
        • Options you shouldn't use
      • Environment variables
        • Debug-mode variables
    • Using Python on Unix platforms
      • Getting and installing the latest version of Python
        • On Linux
        • On FreeBSD and OpenBSD
        • On OpenSolaris
      • Building Python
      • Python-related paths and files
      • Miscellaneous
      • Editors
    • Using Python on Windows
      • Installing Python
        • Installation Steps
        • Installing Without UI
        • Installing Without Downloading
        • Other Platforms
      • Alternative bundles
      • Configuring Python
        • Excursus: Setting environment variables
        • Finding the Python executable
      • Python Launcher for Windows
        • Getting started
          • From the command-line
          • Virtual environments
          • From a script
          • From file associations
        • Shebang Lines
        • Arguments in shebang lines
        • Customization
          • Customization via INI files
          • Customizing default Python versions
        • Diagnostics
      • Finding modules
      • Additional modules
        • PyWin32
        • cx_Freeze
        • WConio
      • Compiling Python on Windows
      • Embedded Distribution
        • Python Application
        • Embedding Python
      • Other resources
    • Using Python on a Macintosh
      • Getting and Installing MacPython
        • How to run a Python script
        • Running scripts with a GUI
        • Configuration
      • The IDE
      • Installing Additional Python Packages
      • GUI Programming on the Mac
      • Distributing Python Applications on the Mac
      • Other Resources
    • Additional Tools and Scripts
      • pyvenv - Creating virtual environments
  • The Python Language Reference
    • Introduction
      • Alternate Implementations
      • Notation
    • Lexical analysis
      • Line structure
        • Logical lines
        • Physical lines
        • Comments
        • Encoding declarations
        • Explicit line joining
        • Implicit line joining
        • Blank lines
        • Indentation
        • Whitespace between tokens
      • Other tokens
      • Identifiers and keywords
        • Keywords
        • Reserved classes of identifiers
      • Literals
        • String and Bytes literals
        • String literal concatenation
        • Numeric literals
        • Integer literals
        • Floating point literals
        • Imaginary literals
      • Operators
      • Delimiters
    • Data model
      • Objects, values and types
      • The standard type hierarchy
      • Special method names
        • Basic customization
        • Customizing attribute access
          • Implementing Descriptors
          • Invoking Descriptors
          • __slots__
            • Notes on using __slots__
        • Customizing class creation
          • Determining the appropriate metaclass
          • Preparing the class namespace
          • Executing the class body
          • Creating the class object
          • Metaclass example
        • Customizing instance and subclass checks
        • Emulating callable objects
        • Emulating container types
        • Emulating numeric types
        • With Statement Context Managers
        • Special method lookup
      • Coroutines
        • Awaitable Objects
        • Coroutine Objects
        • Asynchronous Iterators
        • Asynchronous Context Managers
    • Execution model
      • Structure of a programm
      • Naming and binding
        • Binding of names
        • Resolution of names
        • Builtins and restricted execution
        • Interaction with dynamic features
      • Exceptions
    • The import system
      • importlib
      • Packages
        • Regular packages
        • Namespace packages
      • Searching
        • The module cache
        • Finders and loaders
        • Import hooks
        • The meta path
      • Loading
        • Loaders
        • Submodules
        • Module spec
        • Import-related module attributes
        • module.__path__
        • Module reprs
      • The Path Based Finder
        • Path entry finders
        • Path entry finder protocol
      • Replacing the standard import system
      • Special considerations for __main__
        • __main__.__spec__
      • Open issues
      • References
    • Expressions
      • Arithmetic conversions
      • Atoms
        • Identifiers (Names)
        • Literals
        • Parenthesized forms
        • Displays for lists, sets and dictionaries
        • List displays
        • Set displays
        • Dictionary displays
        • Generator expressions
        • Yield expressions
          • Generator-iterator methods
          • Examples
      • Primaries
        • Attribute references
        • Subscriptions
        • Slicings
        • Calls
      • Await expression
      • The power operator
      • Unary arithmetic and bitwise operations
      • Binary arithmetic operations
      • Shifting operations
      • Binary bitwise operations
      • Comparisons
      • Boolean operations
      • Conditional expressions
      • Lambdas
      • Expression lists
      • Evaluation order
      • Operator precedence
    • Simple statements
      • Expression statements
      • Assignment statements
        • Augmented assignment statements
      • The assert statement
      • The pass statement
      • The del statement
      • The return statement
      • The yield statement
      • The raise statement
      • The break statement
      • The continue statement
      • The import statement
        • Future statements
      • The global statement
      • The nonlocal statement
    • Compound statements
      • The if statement
      • The while statement
      • The for statement
      • The try statement
      • The with statement
      • Function definitions
      • Class definitions
      • Coroutines
        • Coroutine function definition
        • The async for statement
        • The async with statement
    • Top-level components
      • Complete Python programs
      • File input
      • Interactive input
      • Expression input
    • Full Grammar specification
  • The Python Standard Library
    • Introduction
    • Built-in Functions
    • Built-in Constants
      • Constants added by the site module
    • Built-in Types
      • Truth Value Testing
      • Boolean Operations --- and, or, not
      • Comparisons
      • Numeric Types --- int, float, complex
        • Bitwise Operations on Integer Types
        • Additional Methods on Integer Types
        • Additional Methods on Float
        • Hashing of numeric types
      • Iterator Types
        • Generator Types
      • Sequence Types --- list, tuple, range
        • Common Sequence Operations
        • Immutable Sequence Types
        • Mutable Sequence Types
        • Lists
        • Tuples
        • Ranges
      • Text Sequence Type --- str
        • String Methods
        • printf-style String Formatting
      • Binary Sequence Types --- bytes, bytearray, memoryview
        • Bytes
        • Bytearray Objects
        • Bytes and Bytearray Operations
        • printf-style Bytes Formatting
        • Memory Views
      • Set Types --- set, frozenset
      • Mapping Types --- dict
        • Dictionary view objects
      • Context Manager Types
      • Other Built-in Types
        • Modules
        • Classes and Class Instances
        • Functions
        • Methods
        • Code Objects
        • Type Objects
        • The Null Object
        • The Ellipsis Object
        • The NotImplemented Object
        • Boolean Values
        • Internal Objects
      • Special Attributes
    • Built-in Exceptions
      • Base classes
      • Concrete exceptions
        • OS exceptions
      • Warnings
      • Exception hierarchy
    • Text Processing Services
      • string --- Common string operations
        • String constants
        • String Formatting
        • Format String Syntax
          • Format Specification Mini-Language
          • Format examples
        • Template strings
        • Helper functions
      • re --- Regular expression operations
        • Regular Expression Syntax
        • Module Contents
        • Regular Expression Objects
        • Match Objects
        • Regular Expression Examples
          • Checking for a Pair
          • Simulating scanf()
          • search() vs. match()
          • Making a Phonebook
          • Text Munging
          • Finding all Adverbs
          • Finding all Adverbs and their Positions
          • Raw String Notation
          • Writing a Tokenizer
      • difflib --- Helpers for computing deltas
        • SequenceMatcher Objects
        • SequenceMatcher Examples
        • Differ Objects
        • Differ Example
        • A command-line interface to difflib
      • textwrap --- Text wrapping and filling
      • unicodedata --- Unicode Database
      • stringprep --- Internet String Preparation
      • readline --- GNU readline interface
        • Example
      • rlcompleter --- Completion function for GNU readline
        • Completer Objects
    • Binary Data Services
      • struct --- Interpret bytes as packed binary data
        • Functions and Exceptions
        • Format Strings
          • Byte Order, Size, and Alignment
          • Format Characters
          • Examples
        • Classes
      • codecs --- Codec registry and base classes
        • Codec Base Classes
          • Error Handlers
          • Stateless Encoding and Decoding
          • Incremental Encoding and Decoding
            • IncrementalEncoder Objects
            • IncrementalDecoder Objects
          • Stream Encoding and Decoding
            • StreamWriter Objects
            • StreamReader Objects
            • StreamReaderWriter Objects
            • StreamRecoder Objects
        • Encodings and Unicode
        • Standard Encodings
        • Python Specific Encodings
          • Text Encodings
          • Binary Transforms
          • Text Transforms
        • encodings.idna --- Internationalized Domain Names in Applications
        • encodings.mbcs --- Windows ANSI codepage
        • encodings.utf_8_sig --- UTF-8 codec with BOM signature
    • Data Types
      • datetime --- Basic date and time types
        • Available Types
        • timedelta Objects
        • date Objects
        • datetime Objects
        • time Objects
        • tzinfo Objects
        • timezone Objects
        • strftime() and strptime() Behavior
      • calendar --- General calendar-related functions
      • collections --- Container datatypes
        • ChainMap objects
          • ChainMap Examples and Recipes
        • Counter objects
        • deque objects
          • deque Recipes
        • defaultdict objects
          • defaultdict Examples
        • namedtuple() Factory Function for Tuples with Named Fields
        • OrderedDict objects
          • OrderedDict Examples and Recipes
        • UserDict objects
        • UserList objects
        • UserString objects
      • collections.abc --- Abstract Base Classes for Containers
        • Collections Abstract Base Classes
      • heapq --- Heap queue algorithm
        • Basic Examples
        • Priority Queue Implementation Notes
        • Theory
      • bisect --- Array bisection algorithm
        • Searching Sorted Lists
        • Other Examples
      • array --- Efficient arrays of numeric values
      • weakref --- Weak references
        • Weak Reference Objects
        • Example
        • Finalizer Objects
        • Comparing finalizers with __del__() methods
      • types --- Dynamic type creation and names for built-in types
        • Dynamic Type Creation
        • Standard Interpreter Types
        • Additional Utility Classes and Functions
        • Coroutine Utility Functions
      • copy --- Shallow and deep copy operations
      • pprint --- Data pretty printer
        • PrettyPrinter Objects
        • Example
      • reprlib --- Alternate repr() implementation
        • Repr Objects
        • Subclassing Repr Objects
      • enum --- Support for enumerations
        • Module Contents
        • Creating an Enum
        • Programmatic access to enumeration members and their attributes
        • Duplicating enum members and values
        • Ensuring unique enumeration values
        • Iteration
        • Comparisons
        • Allowed members and attributes of enumerations
        • Restricted subclassing of enumerations
        • Pickling
        • Functional API
        • Derived Enumerations
          • IntEnum
          • Others
        • Interesting examples
          • AutoNumber
          • OrderedEnum
          • DuplicateFreeEnum
          • Planet
        • How are Enums different?
          • Enum Classes
          • Enum Members (aka instances)
          • Finer Points
    • Numeric and Mathematical Modules
      • numbers --- Numeric abstract base classes
        • The numeric tower
        • Notes for type implementors
          • Adding More Numeric ABCs
          • Implementing the arithmetic operations
      • math --- Mathematical functions
        • Number-theoretic and representation functions
        • Power and logarithmic functions
        • Trigonometric functions
        • Angular conversion
        • Hyperbolic functions
        • Special functions
        • Constants
      • cmath --- Mathematical functions for complex numbers
        • Conversions to and from polar coordinates
        • Power and logarithmic functions
        • Trigonometric functions
        • Hyperbolic functions
        • Classification functions
        • Constants
      • decimal --- Decimal fixed point and floating point arithmetic
        • Quick-start Tutorial
        • Decimal objects
          • Logical operands
        • Context objects
        • Constants
        • Rounding modes
        • Signals
        • Floating Point Notes
          • Mitigating round-off error with increased precision
          • Special values
        • Working with threads
        • Recipes
        • Decimal FAQ
      • fractions --- Rational numbers
      • random --- Generate pseudo-random numbers
        • Notes on Reproducibility
        • Examples and Recipes
      • statistics --- Mathematical statistics functions
        • Averages and measures of central location
        • Measures of spread
        • Function details
        • Exceptions
    • Functional Programming Modules
      • itertools --- Functions creating iterators for efficient looping
        • Itertool functions
        • Itertools Recipes
      • functools --- Higher-order functions and operations on callable objects
        • partial Objects
      • operator --- Standard operators as functions
        • Mapping Operators to Functions
        • Inplace Operators
    • File and Directory Access
      • pathlib --- Object-oriented filesystem paths
        • Basic use
        • Pure paths
          • General properties
          • Operators
          • Accessing individual parts
          • Methods and properties
        • Concrete paths
          • Methods
      • os.path --- Common pathname manipulations
      • fileinput --- Iterate over lines from multiple input streams
      • stat --- Interpreting stat() results
      • filecmp --- File and Directory Comparisons
        • The dircmp class
      • tempfile --- Generate temporary files and directories
        • Examples
      • glob --- Unix style pathname pattern expansion
      • fnmatch --- Unix filename pattern matching
      • linecache --- Random access to text lines
      • shutil --- High-level file operations
        • Directory and files operations
          • copytree example
          • rmtree example
        • Archiving operations
          • Archiving example
        • Querying the size of the output terminal
      • macpath --- Mac OS 9 path manipulation functions
    • Data Persistence
      • pickle --- Python object serialization
        • Relationship to other Python modules
          • Comparison with marshal
          • Comparison with json
        • Data stream format
        • Module Interface
        • What can be pickled and unpickled?
        • Pickling Class Instances
          • Persistence of External Objects
          • Dispatch Tables
          • Handling Stateful Objects
        • Restricting Globals
        • Performance
        • Examples
      • copyreg --- Register pickle support functions
        • Example
      • shelve --- Python object persistence
        • Restrictions
        • Example
      • marshal --- Internal Python object serialization
      • dbm --- Interfaces to Unix "databases"
        • dbm.gnu --- GNU's reinterpretation of dbm
        • dbm.ndbm --- Interface based on ndbm
        • dbm.dumb --- Portable DBM implementation
      • sqlite3 --- DB-API 2.0 interface for SQLite databases
        • Module functions and constants
        • Connection Objects
        • Cursor Objects
        • Row Objects
        • SQLite and Python types
          • Introduction
          • Using adapters to store additional Python types in SQLite databases
            • Letting your object adapt itself
            • Registering an adapter callable
          • Converting SQLite values to custom Python types
          • Default adapters and converters
        • Controlling Transactions
        • Using sqlite3 efficiently
          • Using shortcut methods
          • Accessing columns by name instead of by index
          • Using the connection as a context manager
        • Common issues
          • Multithreading
    • Data Compression and Archiving
      • zlib --- Compression compatible with gzip
      • gzip --- Support for gzip files
        • Examples of usage
      • bz2 --- Support for bzip2 compression
        • (De)compression of files
        • Incremental (de)compression
        • One-shot (de)compression
      • lzma --- Compression using the LZMA algorithm
        • Reading and writing compressed files
        • Compressing and decompressing data in memory
        • Miscellaneous
        • Specifying custom filter chains
        • Examples
      • zipfile --- Work with ZIP archives
        • ZipFile Objects
        • PyZipFile Objects
        • ZipInfo Objects
      • tarfile --- Read and write tar archive files
        • TarFile Objects
        • TarInfo Objects
        • Command Line Interface
          • Command line options
        • Examples
        • Supported tar formats
        • Unicode issues
    • File Formats
      • csv --- CSV File Reading and Writing
        • Module Contents
        • Dialects and Formatting Parameters
        • Reader Objects
        • Writer Objects
        • Examples
      • configparser --- Configuration file parser
        • Quick Start
        • Supported Datatypes
        • Fallback Values
        • Supported INI File Structure
        • Interpolation of values
        • Mapping Protocol Access
        • Customizing Parser Behaviour
        • Legacy API Examples
        • ConfigParser Objects
        • RawConfigParser Objects
        • Exceptions
      • netrc --- netrc file processing
        • netrc Objects
      • xdrlib --- Encode and decode XDR data
        • Packer Objects
        • Unpacker Objects
        • Exceptions
      • plistlib --- Generate and parse Mac OS X .plist files
        • Examples
    • Cryptographic Services
      • hashlib --- Secure hashes and message digests
        • Hash algorithms
        • Key Derivation Function
      • hmac --- Keyed-Hashing for Message Authentication
    • Generic Operating System Services
      • os --- Miscellaneous operating system interfaces
        • File Names, Command Line Arguments, and Environment Variables
        • Process Parameters
        • File Object Creation
        • File Descriptor Operations
          • Querying the size of a terminal
          • Inheritance of File Descriptors
        • Files and Directories
          • Linux extended attributes
        • Process Management
        • Interface to the scheduler
        • Miscellaneous System Information
        • Miscellaneous Functions
      • io --- Core tools for working with streams
        • Overview
          • Text I/O
          • Binary I/O
          • Raw I/O
        • High-level Module Interface
          • In-memory streams
        • Class hierarchy
          • I/O Base Classes
          • Raw File I/O
          • Buffered Streams
          • Text I/O
        • Performance
          • Binary I/O
          • Text I/O
          • Multi-threading
          • Reentrancy
      • time --- Time access and conversions
      • argparse --- Parser for command-line options, arguments and sub-commands
        • Example
          • Creating a parser
          • Adding arguments
          • Parsing arguments
        • ArgumentParser objects
          • prog
          • usage
          • description
          • epilog
          • parents
          • formatter_class
          • prefix_chars
          • fromfile_prefix_chars
          • argument_default
          • allow_abbrev
          • conflict_handler
          • add_help
        • The add_argument() method
          • name or flags
          • action
          • nargs
          • const
          • default
          • type
          • choices
          • required
          • help
          • metavar
          • dest
          • Action classes
        • The parse_args() method
          • Option value syntax
          • Invalid arguments
          • Arguments containing -
          • Argument abbreviations (prefix matching)
          • Beyond sys.argv
          • The Namespace object
        • Other utilities
          • Sub-commands
          • FileType objects
          • Argument groups
          • Mutual exclusion
          • Parser defaults
          • Printing help
          • Partial parsing
          • Customizing file parsing
          • Exiting methods
        • Upgrading optparse code
      • getopt --- C-style parser for command line options
      • logging --- Logging facility for Python
        • Logger Objects
        • Logging Levels
        • Handler Objects
        • Formatter Objects
        • Filter Objects
        • LogRecord Objects
        • LogRecord attributes
        • LoggerAdapter Objects
        • Thread Safety
        • Module-Level Functions
        • Module-Level Attributes
        • Integration with the warnings module
      • logging.config --- Logging configuration
        • Configuration functions
        • Configuration dictionary schema
          • Dictionary Schema Details
          • Incremental Configuration
          • Object connections
          • User-defined objects
          • Access to external objects
          • Access to internal objects
          • Import resolution and custom importers
        • Configuration file format
      • logging.handlers --- Logging handlers
        • StreamHandler
        • FileHandler
        • NullHandler
        • WatchedFileHandler
        • BaseRotatingHandler
        • RotatingFileHandler
        • TimedRotatingFileHandler
        • SocketHandler
        • DatagramHandler
        • SysLogHandler
        • NTEventLogHandler
        • SMTPHandler
        • MemoryHandler
        • HTTPHandler
        • QueueHandler
        • QueueListener
      • getpass --- Portable password input
      • curses --- Terminal handling for character-cell displays
        • Functions
        • Window Objects
        • Constants
      • curses.textpad --- Text input widget for curses programs
        • Textbox objects
      • curses.ascii --- Utilities for ASCII characters
      • curses.panel --- A panel stack extension for curses
        • Functions
        • Panel Objects
      • platform --- Access to underlying platform's identifying data
        • Cross Platform
        • Java Platform
        • Windows Platform
          • Win95/98 specific
        • Mac OS Platform
        • Unix Platforms
      • errno --- Standard errno system symbols
      • ctypes --- A foreign function library for Python
        • ctypes tutorial
          • Loading dynamic link libraries
          • Accessing functions from loaded dlls
          • Calling functions
          • Fundamental data types
          • Calling functions, continued
          • Calling functions with your own custom data types
          • Specifying the required argument types (function prototypes)
          • Return types
          • Passing pointers (or: passing parameters by reference)
          • Structures and unions
          • Structure/union alignment and byte order
          • Bit fields in structures and unions
          • Arrays
          • Pointers
          • Type conversions
          • Incomplete Types
          • Callback functions
          • Accessing values exported from dlls
          • Surprises
          • Variable-sized data types
        • ctypes reference
          • Finding shared libraries
          • Loading shared libraries
          • Foreign functions
          • Function prototypes
          • Utility functions
          • Data types
          • Fundamental data types
          • Structured data types
          • Arrays and pointers
    • Concurrent Execution
      • threading --- Thread-based parallelism
        • Thread-Local Data
        • Thread Objects
        • Lock Objects
        • RLock Objects
        • Condition Objects
        • Semaphore Objects
          • Semaphore Example
        • Event Objects
        • Timer Objects
        • Barrier Objects
        • Using locks, conditions, and semaphores in the with statement
      • multiprocessing --- Process-based parallelism
        • Introduction
          • The Process class
          • Contexts and start methods
          • Exchanging objects between processes
          • Synchronization between processes
          • Sharing state between processes
          • Using a pool of workers
        • Reference
          • Process and exceptions
          • Pipes and Queues
          • Miscellaneous
          • Connection Objects
          • Synchronization primitives
          • Shared ctypes Objects
            • The multiprocessing.sharedctypes module
          • Managers
            • Namespace objects
            • Customized managers
            • Using a remote manager
          • Proxy Objects
            • Cleanup
          • Process Pools
          • Listeners and Clients
            • Address Formats
          • Authentication keys
          • Logging
          • The multiprocessing.dummy module
        • Programming guidelines
          • All start methods
          • The spawn and forkserver start methods
        • Examples
      • The concurrent package
      • concurrent.futures --- Launching parallel tasks
        • Executor Objects
        • ThreadPoolExecutor
          • ThreadPoolExecutor Example
        • ProcessPoolExecutor
          • ProcessPoolExecutor Example
        • Future Objects
        • Module Functions
        • Exception classes
      • subprocess --- Subprocess management
        • Using the subprocess Module
          • Frequently Used Arguments
          • Popen Constructor
          • Exceptions
        • Security Considerations
        • Popen Objects
        • Windows Popen Helpers
          • Constants
        • Older high-level API
        • Replacing Older Functions with the subprocess Module
          • Replacing /bin/sh shell backquote
          • Replacing shell pipeline
          • Replacing os.system()
          • Replacing the os.spawn family
          • Replacing os.popen(), os.popen2(), os.popen3()
          • Replacing functions from the popen2 module
        • Legacy Shell Invocation Functions
        • Notes
          • Converting an argument sequence to a string on Windows
      • sched --- Event scheduler
        • Scheduler Objects
      • queue --- A synchronized queue class
        • Queue Objects
      • dummy_threading --- Drop-in replacement for the threading module
      • _thread --- Low-level threading API
      • _dummy_thread --- Drop-in replacement for the _thread module
    • Interprocess Communication and Networking
      • socket --- Low-level networking interface
        • Socket families
        • Module contents
          • Exceptions
          • Constants
          • Functions
            • Creating sockets
            • Other functions
        • Socket Objects
        • Notes on socket timeouts
          • Timeouts and the connect method
          • Timeouts and the accept method
        • Example
      • ssl --- TLS/SSL wrapper for socket objects
        • Functions, Constants, and Exceptions
          • Socket creation
          • Context creation
          • Random generation
          • Certificate handling
          • Constants
        • SSL Sockets
        • SSL Contexts
        • Certificates
          • Certificate chains
          • CA certificates
          • Combined key and certificate
          • Self-signed certificates
        • Examples
          • Testing for SSL support
          • Client-side operation
          • Server-side operation
        • Notes on non-blocking sockets
        • Memory BIO Support
        • Security considerations
          • Best defaults
          • Manual settings
            • Verifying certificates
            • Protocol versions
            • Cipher selection
          • Multi-processing
      • select --- Waiting for I/O completion
        • /dev/poll Polling Objects
        • Edge and Level Trigger Polling (epoll) Objects
        • Polling Objects
        • Kqueue Objects
        • Kevent Objects
      • selectors -- High-level I/O multiplexing
        • Introduction
        • Classes
        • Examples
      • asyncio -- Asynchronous I/O, event loop, coroutines and tasks
        • Base Event Loop
          • Run an event loop
          • Calls
          • Delayed calls
          • Tasks
          • Creating connections
          • Creating listening connections
          • Watch file descriptors
          • Low-level socket operations
          • Resolve host name
          • Connect pipes
          • UNIX signals
          • Executor
          • Error Handling API
          • Debug mode
          • Server
          • Handle
          • Event loop examples
            • Hello World with call_soon()
            • Display the current date with call_later()
            • Watch a file descriptor for read events
            • Set signal handlers for SIGINT and SIGTERM
        • Event loops
          • Event loop functions
          • Available event loops
          • Platform support
            • Windows
            • Mac OS X
          • Event loop policies and the default policy
          • Event loop policy interface
          • Access to the global loop policy
        • Tasks and coroutines
          • Coroutines
            • Example: Hello World coroutine
            • Example: Coroutine displaying the current date
            • Example: Chain coroutines
          • InvalidStateError
          • TimeoutError
          • Future
            • Example: Future with run_until_complete()
            • Example: Future with run_forever()
          • Task
            • Example: Parallel execution of tasks
          • Task functions
        • Transports and protocols (low-level API)
          • Transports
            • BaseTransport
            • ReadTransport
            • WriteTransport
            • DatagramTransport
            • BaseSubprocessTransport
          • Protocols
            • Protocol classes
            • Connection callbacks
            • Streaming protocols
            • Datagram protocols
            • Flow control callbacks
            • Coroutines and protocols
          • Protocol examples
            • TCP echo client protocol
            • TCP echo server protocol
            • UDP echo client protocol
            • UDP echo server protocol
            • Register an open socket to wait for data using a protocol
        • Streams (high-level API)
          • Stream functions
          • StreamReader
          • StreamWriter
          • StreamReaderProtocol
          • IncompleteReadError
          • Stream examples
            • TCP echo client using streams
            • TCP echo server using streams
            • Get HTTP headers
            • Register an open socket to wait for data using streams
        • Subprocess
          • Windows event loop
          • Create a subprocess: high-level API using Process
          • Create a subprocess: low-level API using subprocess.Popen
          • Constants
          • Process
        • Subprocess and threads
        • Subprocess examples
          • Subprocess using transport and protocol
          • Subprocess using streams
        • Synchronization primitives
          • Locks
            • Lock
            • Event
            • Condition
          • Semaphores
            • Semaphore
            • BoundedSemaphore
        • Queues
          • Queue
          • PriorityQueue
          • LifoQueue
            • Exceptions
        • Develop with asyncio
          • Debug mode of asyncio
          • Cancellation
          • Concurrency and multithreading
          • Handle blocking functions correctly
          • Logging
          • Detect coroutine objects never scheduled
          • Detect exceptions never consumed
          • Chain coroutines correctly
          • Pending task destroyed
          • Close transports and event loops
      • asyncore --- Asynchronous socket handler
        • asyncore Example basic HTTP client
        • asyncore Example basic echo server
      • asynchat --- Asynchronous socket command/response handler
        • asynchat Example
      • signal --- Set handlers for asynchronous events
        • General rules
          • Execution of Python signal handlers
          • Signals and threads
        • Module contents
        • Example
      • mmap --- Memory-mapped file support
    • Internet Data Handling
      • email --- An email and MIME handling package
        • email.message: Representing an email message
        • email.parser: Parsing email messages
          • FeedParser API
          • Parser class API
          • Additional notes
        • email.generator: Generating MIME documents
        • email.policy: Policy Objects
        • email.headerregistry: Custom Header Objects
        • email.contentmanager: Managing MIME Content
          • Content Manager Instances
        • email.mime: Creating email and MIME objects from scratch
        • email.header: Internationalized headers
        • email.charset: Representing character sets
        • email.encoders: Encoders
        • email.errors: Exception and Defect classes
        • email.utils: Miscellaneous utilities
        • email.iterators: Iterators
        • email: Examples
          • Examples using the Provisional API
        • Package History
        • Differences from mimelib
      • json --- JSON encoder and decoder
        • Basic Usage
        • Encoders and Decoders
        • Exceptions
        • Standard Compliance and Interoperability
          • Character Encodings
          • Infinite and NaN Number Values
          • Repeated Names Within an Object
          • Top-level Non-Object, Non-Array Values
          • Implementation Limitations
        • Command Line Interface
          • Command line options
      • mailcap --- Mailcap file handling
      • mailbox --- Manipulate mailboxes in various formats
        • Mailbox objects
          • Maildir
          • mbox
          • MH
          • Babyl
          • MMDF
        • Message objects
          • MaildirMessage
          • mboxMessage
          • MHMessage
          • BabylMessage
          • MMDFMessage
        • Exceptions
        • Examples
      • mimetypes --- Map filenames to MIME types
        • MimeTypes Objects
      • base64 --- Base16, Base32, Base64, Base85 Data Encodings
      • binhex --- Encode and decode binhex4 files
        • Notes
      • binascii --- Convert between binary and ASCII
      • quopri --- Encode and decode MIME quoted-printable data
      • uu --- Encode and decode uuencode files
    • Structured Markup Processing Tools
      • html --- HyperText Markup Language support
      • html.parser --- Simple HTML and XHTML parser
        • Example HTML Parser Application
        • HTMLParser Methods
        • Examples
      • html.entities --- Definitions of HTML general entities
      • XML Processing Modules
        • XML vulnerabilities
        • The defusedxml and defusedexpat Packages
      • xml.etree.ElementTree --- The ElementTree XML API
        • Tutorial
          • XML tree and elements
          • Parsing XML
          • Pull API for non-blocking parsing
          • Finding interesting elements
          • Modifying an XML File
          • Building XML documents
          • Parsing XML with Namespaces
          • Additional resources
        • XPath support
          • Example
          • Supported XPath syntax
        • Reference
          • Functions
          • Element Objects
          • ElementTree Objects
          • QName Objects
          • TreeBuilder Objects
          • XMLParser Objects
          • XMLPullParser Objects
          • Exceptions
      • xml.dom --- The Document Object Model API
        • Module Contents
        • Objects in the DOM
          • DOMImplementation Objects
          • Node Objects
          • NodeList Objects
          • DocumentType Objects
          • Document Objects
          • Element Objects
          • Attr Objects
          • NamedNodeMap Objects
          • Comment Objects
          • Text and CDATASection Objects
          • ProcessingInstruction Objects
          • Exceptions
        • Conformance
          • Type Mapping
          • Accessor Methods
      • xml.dom.minidom --- Minimal DOM implementation
        • DOM Objects
        • DOM Example
        • minidom and the DOM standard
      • xml.dom.pulldom --- Support for building partial DOM trees
        • DOMEventStream Objects
      • xml.sax --- Support for SAX2 parsers
        • SAXException Objects
      • xml.sax.handler --- Base classes for SAX handlers
        • ContentHandler Objects
        • DTDHandler Objects
        • EntityResolver Objects
        • ErrorHandler Objects
      • xml.sax.saxutils --- SAX Utilities
      • xml.sax.xmlreader --- Interface for XML parsers
        • XMLReader Objects
        • IncrementalParser Objects
        • Locator Objects
        • InputSource Objects
        • The Attributes Interface
        • The AttributesNS Interface
      • xml.parsers.expat --- Fast XML parsing using Expat
        • XMLParser Objects
        • ExpatError Exceptions
        • Example
        • Content Model Descriptions
        • Expat error constants
    • Internet Protocols and Support
      • webbrowser --- Convenient Web-browser controller
        • Browser Controller Objects
      • cgi --- Common Gateway Interface support
        • Introduction
        • Using the cgi module
        • Higher Level Interface
        • Functions
        • Caring about security
        • Installing your CGI script on a Unix system
        • Testing your CGI script
        • Debugging CGI scripts
        • Common problems and solutions
      • cgitb --- Traceback manager for CGI scripts
      • wsgiref --- WSGI Utilities and Reference Implementation
        • wsgiref.util -- WSGI environment utilities
        • wsgiref.headers -- WSGI response header tools
        • wsgiref.simple_server -- a simple WSGI HTTP server
        • wsgiref.validate --- WSGI conformance checker
        • wsgiref.handlers -- server/gateway base classes
        • Examples
      • urllib --- URL handling modules
      • urllib.request --- Extensible library for opening URLs
        • Request Objects
        • OpenerDirector Objects
        • BaseHandler Objects
        • HTTPRedirectHandler Objects
        • HTTPCookieProcessor Objects
        • ProxyHandler Objects
        • HTTPPasswordMgr Objects
        • HTTPPasswordMgrWithPriorAuth Objects
        • AbstractBasicAuthHandler Objects
        • HTTPBasicAuthHandler Objects
        • ProxyBasicAuthHandler Objects
        • AbstractDigestAuthHandler Objects
        • HTTPDigestAuthHandler Objects
        • ProxyDigestAuthHandler Objects
        • HTTPHandler Objects
        • HTTPSHandler Objects
        • FileHandler Objects
        • DataHandler Objects
        • FTPHandler Objects
        • CacheFTPHandler Objects
        • UnknownHandler Objects
        • HTTPErrorProcessor Objects
        • Examples
        • Legacy interface
        • urllib.request Restrictions
      • urllib.response --- Response classes used by urllib
      • urllib.parse --- Parse URLs into components
        • URL Parsing
        • Parsing ASCII Encoded Bytes
        • Structured Parse Results
        • URL Quoting
      • urllib.error --- Exception classes raised by urllib.request
      • urllib.robotparser --- Parser for robots.txt
      • http --- HTTP modules
        • HTTP status codes
      • http.client --- HTTP protocol client
        • HTTPConnection Objects
        • HTTPResponse Objects
        • Examples
        • HTTPMessage Objects
      • ftplib --- FTP protocol client
        • FTP Objects
        • FTP_TLS Objects
      • poplib --- POP3 protocol client
        • POP3 Objects
        • POP3 Example
      • imaplib --- IMAP4 protocol client
        • IMAP4 Objects
        • IMAP4 Example
      • nntplib --- NNTP protocol client
        • NNTP Objects
          • Attributes
          • Methods
        • Utility functions
      • smtplib --- SMTP protocol client
        • SMTP Objects
        • SMTP Example
      • smtpd --- SMTP Server
        • SMTPServer Objects
        • DebuggingServer Objects
        • PureProxy Objects
        • MailmanProxy Objects
        • SMTPChannel Objects
      • telnetlib --- Telnet client
        • Telnet Objects
        • Telnet Example
      • uuid --- UUID objects according to RFC 4122
        • Example
      • socketserver --- A framework for network servers
        • Server Creation Notes
        • Server Objects
        • RequestHandler Objects
        • Examples
          • socketserver.TCPServer Example
          • socketserver.UDPServer Example
          • Asynchronous Mixins
      • http.server --- HTTP servers
      • http.cookies --- HTTP state management
        • Cookie Objects
        • Morsel Objects
        • Example
      • http.cookiejar --- Cookie handling for HTTP clients
        • CookieJar and FileCookieJar Objects
        • FileCookieJar subclasses and co-operation with web browsers
        • CookiePolicy Objects
        • DefaultCookiePolicy Objects
        • Cookie Objects
        • Examples
      • xmlrpc --- XMLRPC server and client modules
      • xmlrpc.client --- XML-RPC client access
        • ServerProxy Objects
        • DateTime Objects
        • Binary Objects
        • Fault Objects
        • ProtocolError Objects
        • MultiCall Objects
        • Convenience Functions
        • Example of Client Usage
        • Example of Client and Server Usage
      • xmlrpc.server --- Basic XML-RPC servers
        • SimpleXMLRPCServer Objects
          • SimpleXMLRPCServer Example
        • CGIXMLRPCRequestHandler
        • Documenting XMLRPC server
        • DocXMLRPCServer Objects
        • DocCGIXMLRPCRequestHandler
      • ipaddress --- IPv4/IPv6 manipulation library
        • Convenience factory functions
        • IP Addresses
          • Address objects
          • Conversion to Strings and Integers
          • Operators
            • Comparison operators
            • Arithmetic operators
        • IP Network definitions
          • Prefix, net mask and host mask
          • Network objects
          • Operators
            • Logical operators
            • Iteration
            • Networks as containers of addresses
        • Interface objects
        • Other Module Level Functions
        • Custom Exceptions
    • Multimedia Services
      • audioop --- Manipulate raw audio data
      • aifc --- Read and write AIFF and AIFC files
      • sunau --- Read and write Sun AU files
        • AU_read Objects
        • AU_write Objects
      • wave --- Read and write WAV files
        • Wave_read Objects
        • Wave_write Objects
      • chunk --- Read IFF chunked data
      • colorsys --- Conversions between color systems
      • imghdr --- Determine the type of an image
      • sndhdr --- Determine type of sound file
      • ossaudiodev --- Access to OSS-compatible audio devices
        • Audio Device Objects
        • Mixer Device Objects
    • Internationalization
      • gettext --- Multilingual internationalization services
        • GNU gettext API
        • Class-based API
          • The NullTranslations class
          • The GNUTranslations class
          • Solaris message catalog support
          • The Catalog constructor
        • Internationalizing your programs and modules
          • Localizing your module
          • Localizing your application
          • Changing languages on the fly
          • Deferred translations
        • Acknowledgements
      • locale --- Internationalization services
        • Background, details, hints, tips and caveats
        • For extension writers and programs that embed Python
        • Access to message catalogs
    • Program Frameworks
      • turtle --- Turtle graphics
        • Introduction
        • Overview of available Turtle and Screen methods
          • Turtle methods
          • Methods of TurtleScreen/Screen
        • Methods of RawTurtle/Turtle and corresponding functions
          • Turtle motion
          • Tell Turtle's state
          • Settings for measurement
          • Pen control
            • Drawing state
            • Color control
            • Filling
            • More drawing control
          • Turtle state
            • Visibility
            • Appearance
          • Using events
          • Special Turtle methods
          • Compound shapes
        • Methods of TurtleScreen/Screen and corresponding functions
          • Window control
          • Animation control
          • Using screen events
          • Input methods
          • Settings and special methods
          • Methods specific to Screen, not inherited from TurtleScreen
        • Public classes
        • Help and configuration
          • How to use help
          • Translation of docstrings into different languages
          • How to configure Screen and Turtles
        • turtledemo --- Demo scripts
        • Changes since Python 2.6
        • Changes since Python 3.0
      • cmd --- Support for line-oriented command interpreters
        • Cmd Objects
        • Cmd Example
      • shlex --- Simple lexical analysis
        • shlex Objects
        • Parsing Rules
    • Graphical User Interfaces with Tk
      • tkinter --- Python interface to Tcl/Tk
        • Tkinter Modules
        • Tkinter Life Preserver
          • How To Use This Section
          • A Simple Hello World Program
        • A (Very) Quick Look at Tcl/Tk
        • Mapping Basic Tk into Tkinter
        • How Tk and Tkinter are Related
        • Handy Reference
          • Setting Options
          • The Packer
          • Packer Options
          • Coupling Widget Variables
          • The Window Manager
          • Tk Option Data Types
          • Bindings and Events
          • The index Parameter
          • Images
        • File Handlers
      • tkinter.ttk --- Tk themed widgets
        • Using Ttk
        • Ttk Widgets
        • Widget
          • Standard Options
          • Scrollable Widget Options
          • Label Options
          • Compatibility Options
          • Widget States
          • ttk.Widget
        • Combobox
          • Options
          • Virtual events
          • ttk.Combobox
        • Notebook
          • Options
          • Tab Options
          • Tab Identifiers
          • Virtual Events
          • ttk.Notebook
        • Progressbar
          • Options
          • ttk.Progressbar
        • Separator
          • Options
        • Sizegrip
          • Platform-specific notes
          • Bugs
        • Treeview
          • Options
          • Item Options
          • Tag Options
          • Column Identifiers
          • Virtual Events
          • ttk.Treeview
        • Ttk Styling
          • Layouts
      • tkinter.tix --- Extension widgets for Tk
        • Using Tix
        • Tix Widgets
          • Basic Widgets
          • File Selectors
          • Hierarchical ListBox
          • Tabular ListBox
          • Manager Widgets
          • Image Types
          • Miscellaneous Widgets
          • Form Geometry Manager
        • Tix Commands
      • tkinter.scrolledtext --- Scrolled Text Widget
      • IDLE
        • Menus
          • File menu (Shell and Editor)
          • Edit menu (Shell and Editor)
          • Format menu (Editor window only)
          • Run menu (Editor window only)
          • Shell menu (Shell window only)
          • Debug menu (Shell window only)
          • Options menu (Shell and Editor)
          • Window menu (Shell and Editor)
          • Help menu (Shell and Editor)
          • Context Menus
        • Editing and navigation
          • Automatic indentation
          • Completions
          • Python Shell window
        • Syntax colors
        • Startup
          • Command line usage
          • Running without a subprocess
        • Help and preferences
          • Additional help sources
          • Setting preferences
          • Extensions
      • Other Graphical User Interface Packages
    • Development Tools
      • typing --- Support for type hints
        • Type aliases
        • Callable
        • Generics
        • User-defined generic types
        • The Any type
        • Default argument values
        • Classes, functions, and decorators
      • pydoc --- Documentation generator and online help system
      • doctest --- Test interactive Python examples
        • Simple Usage: Checking Examples in Docstrings
        • Simple Usage: Checking Examples in a Text File
        • How It Works
          • Which Docstrings Are Examined?
          • How are Docstring Examples Recognized?
          • What's the Execution Context?
          • What About Exceptions?
          • Option Flags
          • Directives
          • Warnings
        • Basic API
        • Unittest API
        • Advanced API
          • DocTest Objects
          • Example Objects
          • DocTestFinder objects
          • DocTestParser objects
          • DocTestRunner objects
          • OutputChecker objects
        • Debugging
        • Soapbox
      • unittest --- Unit testing framework
        • Basic example
        • Command-Line Interface
          • Command-line options
        • Test Discovery
        • Organizing test code
        • Re-using old test code
        • Skipping tests and expected failures
        • Distinguishing test iterations using subtests
        • Classes and functions
          • Test cases
            • Deprecated aliases
          • Grouping tests
          • Loading and running tests
            • load_tests Protocol
        • Class and Module Fixtures
          • setUpClass and tearDownClass
          • setUpModule and tearDownModule
        • Signal Handling
      • unittest.mock --- mock object library
        • Quick Guide
        • The Mock Class
          • Calling
          • Deleting Attributes
          • Mock names and the name attribute
          • Attaching Mocks as Attributes
        • The patchers
          • patch
          • patch.object
          • patch.dict
          • patch.multiple
          • patch methods: start and stop
          • patch builtins
          • TEST_PREFIX
          • Nesting Patch Decorators
          • Where to patch
          • Patching Descriptors and Proxy Objects
        • MagicMock and magic method support
          • Mocking Magic Methods
          • Magic Mock
        • Helpers
          • sentinel
          • DEFAULT
          • call
          • create_autospec
          • ANY
          • FILTER_DIR
          • mock_open
          • Autospeccing
      • unittest.mock --- getting started
        • Using Mock
          • Mock Patching Methods
          • Mock for Method Calls on an Object
          • Mocking Classes
          • Naming your mocks
          • Tracking all Calls
          • Setting Return Values and Attributes
          • Raising exceptions with mocks
          • Side effect functions and iterables
          • Creating a Mock from an Existing Object
        • Patch Decorators
        • Further Examples
          • Mocking chained calls
          • Partial mocking
          • Mocking a Generator Method
          • Applying the same patch to every test method
          • Mocking Unbound Methods
          • Checking multiple calls with mock
          • Coping with mutable arguments
          • Nesting Patches
          • Mocking a dictionary with MagicMock
          • Mock subclasses and their attributes
          • Mocking imports with patch.dict
          • Tracking order of calls and less verbose call assertions
          • More complex argument matching
      • 2to3 - Automated Python 2 to 3 code translation
        • Using 2to3
        • Fixers
        • lib2to3 - 2to3's library
      • test --- Regression tests package for Python
        • Writing Unit Tests for the test package
        • Running tests using the command-line interface
      • test.support --- Utilities for the Python test suite
    • Debugging and Profiling
      • bdb --- Debugger framework
      • faulthandler --- Dump the Python traceback
        • Dumping the traceback
        • Fault handler state
        • Dumping the tracebacks after a timeout
        • Dumping the traceback on a user signal
        • Issue with file descriptors
        • Example
      • pdb --- The Python Debugger
        • Debugger Commands
      • The Python Profilers
        • Introduction to the profilers
        • Instant User's Manual
        • profile and cProfile Module Reference
        • The Stats Class
        • What Is Deterministic Profiling?
        • Limitations
        • Calibration
        • Using a custom timer
      • timeit --- Measure execution time of small code snippets
        • Basic Examples
        • Python Interface
        • Command-Line Interface
        • Examples
      • trace --- Trace or track Python statement execution
        • Command-Line Usage
          • Main options
          • Modifiers
          • Filters
        • Programmatic Interface
      • tracemalloc --- Trace memory allocations
        • Examples
          • Display the top 10
          • Compute differences
          • Get the traceback of a memory block
          • Pretty top
        • API
          • Functions
          • Filter
          • Frame
          • Snapshot
          • Statistic
          • StatisticDiff
          • Trace
          • Traceback
    • Software Packaging and Distribution
      • distutils --- Building and installing Python modules
      • ensurepip --- Bootstrapping the pip installer
        • Command line interface
        • Module API
      • venv --- Creation of virtual environments
        • Creating virtual environments
        • API
        • An example of extending EnvBuilder
      • zipapp --- Manage executable python zip archives
        • Basic Example
        • Command-Line Interface
        • Python API
        • Examples
        • The Python Zip Application Archive Format
    • Python Runtime Services
      • sys --- System-specific parameters and functions
      • sysconfig --- Provide access to Python's configuration information
        • Configuration variables
        • Installation paths
        • Other functions
        • Using sysconfig as a script
      • builtins --- Built-in objects
      • __main__ --- Top-level script environment
      • warnings --- Warning control
        • Warning Categories
        • The Warnings Filter
          • Default Warning Filters
        • Temporarily Suppressing Warnings
        • Testing Warnings
        • Updating Code For New Versions of Python
        • Available Functions
        • Available Context Managers
      • contextlib --- Utilities for with-statement contexts
        • Utilities
        • Examples and Recipes
          • Supporting a variable number of context managers
          • Simplifying support for single optional context managers
          • Catching exceptions from __enter__ methods
          • Cleaning up in an __enter__ implementation
          • Replacing any use of try-finally and flag variables
          • Using a context manager as a function decorator
        • Single use, reusable and reentrant context managers
          • Reentrant context managers
          • Reusable context managers
      • abc --- Abstract Base Classes
      • atexit --- Exit handlers
        • atexit Example
      • traceback --- Print or retrieve a stack traceback
        • TracebackException Objects
        • StackSummary Objects
        • FrameSummary Objects
        • Traceback Examples
      • __future__ --- Future statement definitions
      • gc --- Garbage Collector interface
      • inspect --- Inspect live objects
        • Types and members
        • Retrieving source code
        • Introspecting callables with the Signature object
        • Classes and functions
        • The interpreter stack
        • Fetching attributes statically
        • Current State of Generators and Coroutines
        • Command Line Interface
      • site --- Site-specific configuration hook
        • Readline configuration
        • Module contents
      • fpectl --- Floating point exception control
        • Example
        • Limitations and other considerations
    • Custom Python Interpreters
      • code --- Interpreter base classes
        • Interactive Interpreter Objects
        • Interactive Console Objects
      • codeop --- Compile Python code
    • Importing Modules
      • zipimport --- Import modules from Zip archives
        • zipimporter Objects
        • Examples
      • pkgutil --- Package extension utility
      • modulefinder --- Find modules used by a script
        • Example usage of ModuleFinder
      • runpy --- Locating and executing Python modules
      • importlib -- The implementation of import
        • Introduction
        • Functions
        • importlib.abc -- Abstract base classes related to import
        • importlib.machinery -- Importers and path hooks
        • importlib.util -- Utility code for importers
    • Python Language Services
      • parser --- Access Python parse trees
        • Creating ST Objects
        • Converting ST Objects
        • Queries on ST Objects
        • Exceptions and Error Handling
        • ST Objects
        • Example: Emulation of compile()
      • ast --- Abstract Syntax Trees
        • Node classes
        • Abstract Grammar
        • ast Helpers
      • symtable --- Access to the compiler's symbol tables
        • Generating Symbol Tables
        • Examining Symbol Tables
      • symbol --- Constants used with Python parse trees
      • token --- Constants used with Python parse trees
      • keyword --- Testing for Python keywords
      • tokenize --- Tokenizer for Python source
        • Tokenizing Input
        • Command-Line Usage
        • Examples
      • tabnanny --- Detection of ambiguous indentation
      • pyclbr --- Python class browser support
        • Class Objects
        • Function Objects
      • py_compile --- Compile Python source files
      • compileall --- Byte-compile Python libraries
        • Command-line use
        • Public functions
      • dis --- Disassembler for Python bytecode
        • Bytecode analysis
        • Analysis functions
        • Python Bytecode Instructions
        • Opcode collections
      • pickletools --- Tools for pickle developers
        • Command line usage
          • Command line options
        • Programmatic Interface
    • Miscellaneous Services
      • formatter --- Generic output formatting
        • The Formatter Interface
        • Formatter Implementations
        • The Writer Interface
        • Writer Implementations
    • MS Windows Specific Services
      • msilib --- Read and write Microsoft Installer files
        • Database Objects
        • View Objects
        • Summary Information Objects
        • Record Objects
        • Errors
        • CAB Objects
        • Directory Objects
        • Features
        • GUI classes
        • Precomputed tables
      • msvcrt -- Useful routines from the MS VC++ runtime
        • File Operations
        • Console I/O
        • Other Functions
      • winreg -- Windows registry access
        • Functions
        • Constants
          • HKEY_* Constants
          • Access Rights
            • 64-bit Specific
          • Value Types
        • Registry Handle Objects
      • winsound --- Sound-playing interface for Windows
    • Unix Specific Services
      • posix --- The most common POSIX system calls
        • Large File Support
        • Notable Module Contents
      • pwd --- The password database
      • spwd --- The shadow password database
      • grp --- The group database
      • crypt --- Function to check Unix passwords
        • Hashing Methods
        • Module Attributes
        • Module Functions
        • Examples
      • termios --- POSIX style tty control
        • Example
      • tty --- Terminal control functions
      • pty --- Pseudo-terminal utilities
        • Example
      • fcntl --- The fcntl and ioctl system calls
      • pipes --- Interface to shell pipelines
        • Template Objects
      • resource --- Resource usage information
        • Resource Limits
        • Resource Usage
      • nis --- Interface to Sun's NIS (Yellow Pages)
      • syslog --- Unix syslog library routines
        • Examples
          • Simple example
    • Superseded Modules
      • optparse --- Parser for command line options
        • Background
          • Terminology
          • What are options for?
          • What are positional arguments for?
        • Tutorial
          • Understanding option actions
          • The store action
          • Handling boolean (flag) options
          • Other actions
          • Default values
          • Generating help
            • Grouping Options
          • Printing a version string
          • How optparse handles errors
          • Putting it all together
        • Reference Guide
          • Creating the parser
          • Populating the parser
          • Defining options
          • Option attributes
          • Standard option actions
          • Standard option types
          • Parsing arguments
          • Querying and manipulating your option parser
          • Conflicts between options
          • Cleanup
          • Other methods
        • Option Callbacks
          • Defining a callback option
          • How callbacks are called
          • Raising errors in a callback
          • Callback example 1: trivial callback
          • Callback example 2: check option order
          • Callback example 3: check option order (generalized)
          • Callback example 4: check arbitrary condition
          • Callback example 5: fixed arguments
          • Callback example 6: variable arguments
        • Extending optparse
          • Adding new types
          • Adding new actions
      • imp --- Access the import internals
        • Examples
    • Undocumented Modules
      • Platform specific modules
  • Extending and Embedding the Python Interpreter
    • Recommended third party tools
    • Creating extensions without third party tools
      • Extending Python with C or C++
        • A Simple Example
        • Intermezzo: Errors and Exceptions
        • Back to the Example
        • The Module's Method Table and Initialization Function
        • Compilation and Linkage
        • Calling Python Functions from C
        • Extracting Parameters in Extension Functions
        • Keyword Parameters for Extension Functions
        • Building Arbitrary Values
        • Reference Counts
          • Reference Counting in Python
          • Ownership Rules
          • Thin Ice
          • NULL Pointers
        • Writing Extensions in C++
        • Providing a C API for an Extension Module
      • Defining New Types
        • The Basics
          • Adding data and methods to the Basic example
          • Providing finer control over data attributes
          • Supporting cyclic garbage collection
          • Subclassing other types
        • Type Methods
          • Finalization and De-allocation
          • Object Presentation
          • Attribute Management
            • Generic Attribute Management
            • Type-specific Attribute Management
          • Object Comparison
          • Abstract Protocol Support
          • Weak Reference Support
          • More Suggestions
      • Building C and C++ Extensions
        • Building C and C++ Extensions with distutils
        • Distributing your extension modules
      • Building C and C++ Extensions on Windows
        • A Cookbook Approach
        • Differences Between Unix and Windows
        • Using DLLs in Practice
    • Embedding the CPython runtime in a larger application
      • Embedding Python in Another Application
        • Very High Level Embedding
        • Beyond Very High Level Embedding: An overview
        • Pure Embedding
        • Extending Embedded Python
        • Embedding Python in C++
        • Compiling and Linking under Unix-like systems
  • Python/C API Reference Manual
    • Introduction
      • Include Files
      • Objects, Types and Reference Counts
        • Reference Counts
          • Reference Count Details
        • Types
      • Exceptions
      • Embedding Python
      • Debugging Builds
    • Stable Application Binary Interface
    • The Very High Level Layer
    • Reference Counting
    • Exception Handling
      • Printing and clearing
      • Raising exceptions
      • Issuing warnings
      • Querying the error indicator
      • Signal Handling
      • Exception Classes
      • Exception Objects
      • Unicode Exception Objects
      • Recursion Control
      • Standard Exceptions
    • Utilities
      • Operating System Utilities
      • System Functions
      • Process Control
      • Importing Modules
      • Data marshalling support
      • Parsing arguments and building values
        • Parsing arguments
          • Strings and buffers
          • Numbers
          • Other objects
          • API Functions
        • Building values
      • String conversion and formatting
      • Reflection
      • Codec registry and support functions
        • Codec lookup API
        • Registry API for Unicode encoding error handlers
    • Abstract Objects Layer
      • Object Protocol
      • Number Protocol
      • Sequence Protocol
      • Mapping Protocol
      • Iterator Protocol
      • Buffer Protocol
        • Buffer structure
        • Buffer request types
          • request-independent fields
          • readonly, format
          • shape, strides, suboffsets
          • contiguity requests
          • compound requests
        • Complex arrays
          • NumPy-style: shape and strides
          • PIL-style: shape, strides and suboffsets
        • Buffer-related functions
      • Old Buffer Protocol
    • Concrete Objects Layer
      • Fundamental Objects
        • Type Objects
        • The None Object
      • Numeric Objects
        • Integer Objects
        • Boolean Objects
        • Floating Point Objects
        • Complex Number Objects
          • Complex Numbers as C Structures
          • Complex Numbers as Python Objects
      • Sequence Objects
        • Bytes Objects
        • Byte Array Objects
          • Type check macros
          • Direct API functions
          • Macros
        • Unicode Objects and Codecs
          • Unicode Objects
            • Unicode Type
            • Unicode Character Properties
            • Creating and accessing Unicode strings
            • Deprecated Py_UNICODE APIs
            • Locale Encoding
            • File System Encoding
            • wchar_t Support
            • UCS4 Support
          • Built-in Codecs
            • Generic Codecs
            • UTF-8 Codecs
            • UTF-32 Codecs
            • UTF-16 Codecs
            • UTF-7 Codecs
            • Unicode-Escape Codecs
            • Raw-Unicode-Escape Codecs
            • Latin-1 Codecs
            • ASCII Codecs
            • Character Map Codecs
            • MBCS codecs for Windows
            • Methods & Slots
          • Methods and Slot Functions
        • Tuple Objects
        • Struct Sequence Objects
        • List Objects
      • Container Objects
        • Dictionary Objects
        • Set Objects
      • Function Objects
        • Function Objects
        • Instance Method Objects
        • Method Objects
        • Cell Objects
        • Code Objects
      • Other Objects
        • File Objects
        • Module Objects
          • Initializing C modules
            • Single-phase initialization
            • Multi-phase initialization
            • Low-level module creation functions
            • Support functions
          • Module lookup
        • Iterator Objects
        • Descriptor Objects
        • Slice Objects
        • MemoryView objects
        • Weak Reference Objects
        • Capsules
        • Generator Objects
        • Coroutine Objects
        • DateTime Objects
    • Initialization, Finalization, and Threads
      • Initializing and finalizing the interpreter
      • Process-wide parameters
      • Thread State and the Global Interpreter Lock
        • Releasing the GIL from extension code
        • Non-Python created threads
        • High-level API
        • Low-level API
      • Sub-interpreter support
        • Bugs and caveats
      • Asynchronous Notifications
      • Profiling and Tracing
      • Advanced Debugger Support
    • Memory Management
      • Overview
      • Raw Memory Interface
      • Memory Interface
      • Customize Memory Allocators
      • Customize PyObject Arena Allocator
      • Examples
    • Object Implementation Support
      • Allocating Objects on the Heap
      • Common Object Structures
      • Type Objects
      • Number Object Structures
      • Mapping Object Structures
      • Sequence Object Structures
      • Buffer Object Structures
      • Async Object Structures
      • Supporting Cyclic Garbage Collection
    • API and ABI Versioning
  • Distributing Python Modules
    • Key terms
    • Open source licensing and collaboration
    • Installing the tools
    • Reading the guide
    • How do I...?
      • ... choose a name for my project?
      • ... create and distribute binary extensions?
  • Installing Python Modules
    • Key terms
    • Basic usage
    • How do I ...?
      • ... install pip in versions of Python prior to Python 3.4?
      • ... install packages just for the current user?
      • ... install scientific Python packages?
      • ... work with multiple versions of Python installed in parallel?
    • Common installation issues
      • Installing into the system Python on Linux
      • Installing binary extensions
  • Python HOWTOs
    • Porting Python 2 Code to Python 3
      • The Short Explanation
      • Details
        • Drop support for Python 2.6 and older
        • Make sure you specify the proper version support in your setup.py file
        • Have good test coverage
        • Learn the differences between Python 2 & 3
        • Update your code
          • Division
          • Text versus binary data
        • Prevent compatibility regressions
        • Check which dependencies block your transition
        • Update your setup.py file to denote Python 3 compatibility
        • Use continuous integration to stay compatible
      • Dropping Python 2 support completely
    • Porting Extension Modules to Python 3
      • Conditional compilation
      • Changes to Object APIs
        • str/unicode Unification
        • long/int Unification
      • Module initialization and state
      • CObject replaced with Capsule
      • Other options
    • Curses Programming with Python
      • What is curses?
        • The Python curses module
      • Starting and ending a curses application
      • Windows and Pads
      • Displaying Text
        • Attributes and Color
      • User Input
      • For More Information
    • Descriptor HowTo Guide
      • Abstract
      • Definition and Introduction
      • Descriptor Protocol
      • Invoking Descriptors
      • Descriptor Example
      • Properties
      • Functions and Methods
      • Static Methods and Class Methods
    • Functional Programming HOWTO
      • Introduction
        • Formal provability
        • Modularity
        • Ease of debugging and testing
        • Composability
      • Iterators
        • Data Types That Support Iterators
      • Generator expressions and list comprehensions
      • Generators
        • Passing values into a generator
      • Built-in functions
      • The itertools module
        • Creating new iterators
        • Calling functions on elements
        • Selecting elements
        • Combinatoric functions
        • Grouping elements
      • The functools module
        • The operator module
      • Small functions and the lambda expression
      • Revision History and Acknowledgements
      • References
        • General
        • Python-specific
        • Python documentation
    • Logging HOWTO
      • Basic Logging Tutorial
        • When to use logging
        • A simple example
        • Logging to a file
        • Logging from multiple modules
        • Logging variable data
        • Changing the format of displayed messages
        • Displaying the date/time in messages
        • Next Steps
      • Advanced Logging Tutorial
        • Logging Flow
        • Loggers
        • Handlers
        • Formatters
        • Configuring Logging
        • What happens if no configuration is provided
        • Configuring Logging for a Library
      • Logging Levels
        • Custom Levels
      • Useful Handlers
      • Exceptions raised during logging
      • Using arbitrary objects as messages
      • Optimization
    • Logging Cookbook
      • Using logging in multiple modules
      • Multiple handlers and formatters
      • Logging to multiple destinations
      • Configuration server example
      • Dealing with handlers that block
      • Sending and receiving logging events across a network
      • Adding contextual information to your logging output
        • Using LoggerAdapters to impart contextual information
          • Using objects other than dicts to pass contextual information
        • Using Filters to impart contextual information
      • Logging to a single file from multiple processes
      • Using file rotation
      • Use of alternative formatting styles
      • Customizing LogRecord
      • Subclassing QueueHandler - a ZeroMQ example
      • Subclassing QueueListener - a ZeroMQ example
      • An example dictionary-based configuration
      • Using a rotator and namer to customize log rotation processing
      • A more elaborate multiprocessing example
      • Inserting a BOM into messages sent to a SysLogHandler
      • Implementing structured logging
      • Customizing handlers with dictConfig()
      • Using particular formatting styles throughout your application
        • Using LogRecord factories
        • Using custom message objects
      • Configuring filters with dictConfig()
      • Customized exception formatting
      • Speaking logging messages
    • Regular Expression HOWTO
      • Introduction
      • Simple Patterns
        • Matching Characters
        • Repeating Things
      • Using Regular Expressions
        • Compiling Regular Expressions
        • The Backslash Plague
        • Performing Matches
        • Module-Level Functions
        • Compilation Flags
      • More Pattern Power
        • More Metacharacters
        • Grouping
        • Non-capturing and Named Groups
        • Lookahead Assertions
      • Modifying Strings
        • Splitting Strings
        • Search and Replace
      • Common Problems
        • Use String Methods
        • match() versus search()
        • Greedy versus Non-Greedy
        • Using re.VERBOSE
      • Feedback
    • Socket Programming HOWTO
      • Sockets
        • History
      • Creating a Socket
        • IPC
      • Using a Socket
        • Binary Data
      • Disconnecting
        • When Sockets Die
      • Non-blocking Sockets
    • Sorting HOW TO
      • Sorting Basics
      • Key Functions
      • Operator Module Functions
      • Ascending and Descending
      • Sort Stability and Complex Sorts
      • The Old Way Using Decorate-Sort-Undecorate
      • The Old Way Using the cmp Parameter
      • Odd and Ends
    • Unicode HOWTO
      • Introduction to Unicode
        • History of Character Codes
        • Definitions
        • Encodings
        • References
      • Python's Unicode Support
        • The String Type
        • Converting to Bytes
        • Unicode Literals in Python Source Code
        • Unicode Properties
        • Unicode Regular Expressions
        • References
      • Reading and Writing Unicode Data
        • Unicode filenames
        • Tips for Writing Unicode-aware Programs
          • Converting Between File Encodings
          • Files in an Unknown Encoding
        • References
      • Acknowledgements
    • HOWTO Fetch Internet Resources Using The urllib Package
      • Introduction
      • Fetching URLs
        • Data
        • Headers
      • Handling Exceptions
        • URLError
        • HTTPError
          • Error Codes
        • Wrapping it Up
          • Number 1
          • Number 2
      • info and geturl
      • Openers and Handlers
      • Basic Authentication
      • Proxies
      • Sockets and Layers
      • Footnotes
    • HOWTO Use Python in the web
      • The Low-Level View
        • Common Gateway Interface
          • Simple script for testing CGI
          • Setting up CGI on your own server
          • Common problems with CGI scripts
        • mod_python
        • FastCGI and SCGI
          • Setting up FastCGI
        • mod_wsgi
      • Step back: WSGI
        • WSGI Servers
        • Case study: MoinMoin
      • Model-View-Controller
      • Ingredients for Websites
        • Templates
        • Data persistence
      • Frameworks
        • Some notable frameworks
          • Django
          • TurboGears
          • Zope
          • Other notable frameworks
    • Argparse Tutorial
      • Concepts
      • The basics
      • Introducing Positional arguments
      • Introducing Optional arguments
        • Short options
      • Combining Positional and Optional arguments
      • Getting a little more advanced
        • Conflicting options
      • Conclusion
    • An introduction to the ipaddress module
      • Creating Address/Network/Interface objects
        • A Note on IP Versions
        • IP Host Addresses
        • Defining Networks
        • Host Interfaces
      • Inspecting Address/Network/Interface Objects
      • Networks as lists of Addresses
      • Comparisons
      • Using IP Addresses with other modules
      • Getting more detail when instance creation fails
    • Argument Clinic How-To
      • The Goals Of Argument Clinic
      • Basic Concepts And Usage
      • Converting Your First Function
      • Advanced Topics
        • Symbolic default values
        • Renaming the C functions and variables generated by Argument Clinic
        • Converting functions using PyArg_UnpackTuple
        • Optional Groups
        • Using real Argument Clinic converters, instead of "legacy converters"
        • Py_buffer
        • Advanced converters
        • Parameter default values
        • The NULL default value
        • Expressions specified as default values
        • Using a return converter
        • Cloning existing functions
        • Calling Python code
        • Using a "self converter"
        • Writing a custom converter
        • Writing a custom return converter
        • METH_O and METH_NOARGS
        • tp_new and tp_init functions
        • Changing and redirecting Clinic's output
        • The #ifdef trick
        • Using Argument Clinic in Python files
  • Python Frequently Asked Questions
    • General Python FAQ
      • General Information
      • Python in the real world
    • Programming FAQ
      • General Questions
      • Core Language
      • Numbers and strings
      • Performance
      • Sequences (Tuples/Lists)
      • Dictionaries
      • Objects
      • Modules
    • Design and History FAQ
      • Why does Python use indentation for grouping of statements?
      • Why am I getting strange results with simple arithmetic operations?
      • Why are floating-point calculations so inaccurate?
      • Why are Python strings immutable?
      • Why must 'self' be used explicitly in method definitions and calls?
      • Why can't I use an assignment in an expression?
      • Why does Python use methods for some functionality (e.g. list.index()) but functions for other (e.g. len(list))?
      • Why is join() a string method instead of a list or tuple method?
      • How fast are exceptions?
      • Why isn't there a switch or case statement in Python?
      • Can't you emulate threads in the interpreter instead of relying on an OS-specific thread implementation?
      • Why can't lambda expressions contain statements?
      • Can Python be compiled to machine code, C or some other language?
      • How does Python manage memory?
      • Why doesn't CPython use a more traditional garbage collection scheme?
      • Why isn't all memory freed when CPython exits?
      • Why are there separate tuple and list data types?
      • How are lists implemented?
      • How are dictionaries implemented?
      • Why must dictionary keys be immutable?
      • Why doesn't list.sort() return the sorted list?
      • How do you specify and enforce an interface spec in Python?
      • Why is there no goto?
      • Why can't raw strings (r-strings) end with a backslash?
      • Why doesn't Python have a "with" statement for attribute assignments?
      • Why are colons required for the if/while/def/class statements?
      • Why does Python allow commas at the end of lists and tuples?
    • Library and Extension FAQ
      • General Library Questions
      • Common tasks
      • Threads
      • Input and Output
      • Network/Internet Programming
      • Databases
      • Mathematics and Numerics
    • Extending/Embedding FAQ
      • Can I create my own functions in C?
      • Can I create my own functions in C++?
      • Writing C is hard; are there any alternatives?
      • How can I execute arbitrary Python statements from C?
      • How can I evaluate an arbitrary Python expression from C?
      • How do I extract C values from a Python object?
      • How do I use Py_BuildValue() to create a tuple of arbitrary length?
      • How do I call an object's method from C?
      • How do I catch the output from PyErr_Print() (or anything that prints to stdout/stderr)?
      • How do I access a module written in Python from C?
      • How do I interface to C++ objects from Python?
      • I added a module using the Setup file and the make fails; why?
      • How do I debug an extension?
      • I want to compile a Python module on my Linux system, but some files are missing. Why?
      • What does "SystemError: _PyImport_FixupExtension: module yourmodule not loaded" mean?
      • How do I tell "incomplete input" from "invalid input"?
      • How do I find undefined g++ symbols __builtin_new or __pure_virtual?
      • Can I create an object class with some methods implemented in C and others in Python (e.g. through inheritance)?
    • Python on Windows FAQ
      • How do I run a Python program under Windows?
      • How do I make Python scripts executable?
      • Why does Python sometimes take so long to start?
      • How do I make an executable from a Python script?
      • Is a *.pyd file the same as a DLL?
      • How can I embed Python into a Windows application?
      • How do I keep editors from inserting tabs into my Python source?
      • How do I check for a keypress without blocking?
      • How do I emulate os.kill() in Windows?
      • How do I extract the downloaded documentation on Windows?
    • Graphic User Interface FAQ
      • General GUI Questions
      • What platform-independent GUI toolkits exist for Python?
      • What platform-specific GUI toolkits exist for Python?
      • Tkinter questions
    • "Why is Python Installed on my Computer?" FAQ
      • What is Python?
      • Why is Python installed on my machine?
      • Can I delete Python?
  • Glossary
  • About these documents
    • Contributors to the Python Documentation
  • Reporting Bugs
    • Documentation bugs
    • Using the Python issue tracker
    • Getting started contributing to Python yourself
  • Copyright
  • History and License
    • History of the software
    • Terms and conditions for accessing or otherwise using Python
    • Licenses and Acknowledgements for Incorporated Software
      • Mersenne Twister
      • Sockets
      • Floating point exception control
      • Asynchronous socket services
      • Cookie management
      • Execution tracing
      • UUencode and UUdecode functions
      • XML Remote Procedure Calls
      • test_epoll
      • Select kqueue
      • SipHash24
      • strtod and dtoa
      • OpenSSL
      • expat
      • libffi
      • zlib
      • cfuhash
      • libmpdec

Get in touch

Submit feedback about this site to:

  • [email protected]

© documentation.help. Design: rehmann.co.