Python Documentation contents
From Python 3.4.4
Navigation
- index
- modules |
- next |
- Python »
- 3.4.4 Documentation »
Python Documentation contents
- What’s New in Python
- What’s New In Python 3.4
- Summary – Release Highlights
- New Features
- New Modules
- Improved Modules
- abc
- aifc
- argparse
- audioop
- base64
- collections
- colorsys
- contextlib
- dbm
- dis
- doctest
- 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
- Deprecated
- Removed
- Porting to Python 3.4
- Changed in 3.4.3
- 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
- PEP 393: Flexible String Representation
- 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
- Using importlib as the Implementation of Import
- Other Language Changes
- A Finer-Grained Import Lock
- Builtin functions and types
- New Modules
- Improved Modules
- abc
- array
- base64
- binascii
- bz2
- codecs
- collections
- contextlib
- crypt
- curses
- datetime
- decimal
- 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
- Porting to Python 3.3
- 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
- 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
- What’s New In 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
- New and Improved Modules
- Build and C API Changes
- Other Changes and Fixes
- Porting to Python 2.7
- New Features Added to Python 2.7 Maintenance Releases
- Acknowledgements
- What’s New in Python 2.6
- Python 3.0
- Changes to the Development Process
- PEP 343: The ‘with’ statement
- 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
- Other Language Changes
- New and Improved Modules
- Deprecations and Removals
- Build and C API Changes
- 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
- PEP 352: Exceptions as New-Style Classes
- PEP 353: Using ssize_t as the index type
- PEP 357: The ‘__index__’ method
- Other Language Changes
- New, Improved, and Removed Modules
- Build and C API 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
- PEP 328: Multi-line Imports
- PEP 331: Locale-Independent Float/String Conversions
- Other Language Changes
- New, Improved, and Deprecated Modules
- Build and C API 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
- New, Improved, and Deprecated Modules
- Pymalloc: A Specialized Object Allocator
- Build and C API 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
- 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
- Porting to 2.0
- Extending/Embedding Changes
- Distutils: Making Modules Easy to Install
- XML Modules
- Module changes
- New modules
- IDLE Improvements
- Deleted and Deprecated Modules
- Acknowledgements
- Changelog
- Python 3.4.4?
- Python 3.4.4rc1?
- Python 3.4.3?
- Python 3.4.2?
- Python 3.4.2rc1?
- Python 3.4.1?
- Python 3.4.1rc1?
- Python 3.4.0?
- Python 3.4.0 release candidate 3?
- Python 3.4.0 release candidate 2?
- Python 3.4.0 release candidate 1?
- Python 3.4.0 Beta 3?
- Python 3.4.0 Beta 2?
- Python 3.4.0 Beta 1?
- Python 3.4.0 Alpha 4?
- Python 3.4.0 Alpha 3?
- Python 3.4.0 Alpha 2?
- Python 3.4.0 Alpha 1?
- Python 3.3.0?
- Python 3.3.0 Release Candidate 3?
- Python 3.3.0 Release Candidate 2?
- Python 3.3.0 Release Candidate 1?
- Python 3.3.0 Beta 2?
- Python 3.3.0 Beta 1?
- Python 3.3.0 Alpha 4?
- Python 3.3.0 Alpha 3?
- Python 3.3.0 Alpha 2?
- Python 3.3.0 Alpha 1?
- What’s New In Python 3.4
- The Python Tutorial
- 1. Whetting Your Appetite
- 2. Using the Python Interpreter
- 3. An Informal Introduction to Python
- 4. More Control Flow Tools
- 5. Data Structures
- 6. Modules
- 7. Input and Output
- 8. Errors and Exceptions
- 9. Classes
- 10. Brief Tour of the Standard Library
- 10.1. Operating System Interface
- 10.2. File Wildcards
- 10.3. Command Line Arguments
- 10.4. Error Output Redirection and Program Termination
- 10.5. String Pattern Matching
- 10.6. Mathematics
- 10.7. Internet Access
- 10.8. Dates and Times
- 10.9. Data Compression
- 10.10. Performance Measurement
- 10.11. Quality Control
- 10.12. Batteries Included
- 11. Brief Tour of the Standard Library – Part II
- 12. Virtual Environments and Packages
- 13. What Now?
- 14. Interactive Input Editing and History Substitution
- 15. Floating Point Arithmetic: Issues and Limitations
- 16. Appendix
- Python Setup and Usage
- 1. Command line and environment
- 2. Using Python on Unix platforms
- 3. Using Python on Windows
- 4. Using Python on a Macintosh
- 5. Additional Tools and Scripts
- The Python Language Reference
- 1. Introduction
- 2. Lexical analysis
- 3. Data model
- 3.1. Objects, values and types
- 3.2. The standard type hierarchy
- 3.3. Special method names
- 3.3.1. Basic customization
- 3.3.2. Customizing attribute access
- 3.3.3. Customizing class creation
- 3.3.4. Customizing instance and subclass checks
- 3.3.5. Emulating callable objects
- 3.3.6. Emulating container types
- 3.3.7. Emulating numeric types
- 3.3.8. With Statement Context Managers
- 3.3.9. Special method lookup
- 4. Execution model
- 5. The import system
- 6. Expressions
- 6.1. Arithmetic conversions
- 6.2. Atoms
- 6.3. Primaries
- 6.4. The power operator
- 6.5. Unary arithmetic and bitwise operations
- 6.6. Binary arithmetic operations
- 6.7. Shifting operations
- 6.8. Binary bitwise operations
- 6.9. Comparisons
- 6.10. Boolean operations
- 6.11. Conditional expressions
- 6.12. Lambdas
- 6.13. Expression lists
- 6.14. Evaluation order
- 6.15. Operator precedence
- 7. Simple statements
- 7.1. Expression statements
- 7.2. Assignment statements
- 7.3. The assert statement
- 7.4. The pass statement
- 7.5. The del statement
- 7.6. The return statement
- 7.7. The yield statement
- 7.8. The raise statement
- 7.9. The break statement
- 7.10. The continue statement
- 7.11. The import statement
- 7.12. The global statement
- 7.13. The nonlocal statement
- 8. Compound statements
- 9. Top-level components
- 10. Full Grammar specification
- The Python Standard Library
- 1. Introduction
- 2. Built-in Functions
- 3. Built-in Constants
- 4. Built-in Types
- 4.1. Truth Value Testing
- 4.2. Boolean Operations — and, or, not
- 4.3. Comparisons
- 4.4. Numeric Types — int, float, complex
- 4.5. Iterator Types
- 4.6. Sequence Types — list, tuple, range
- 4.7. Text Sequence Type — str
- 4.8. Binary Sequence Types — bytes, bytearray, memoryview
- 4.9. Set Types — set, frozenset
- 4.10. Mapping Types — dict
- 4.11. Context Manager Types
- 4.12. Other Built-in Types
- 4.13. Special Attributes
- 5. Built-in Exceptions
- 6. Text Processing Services
- 6.1. string — Common string operations
- 6.2. re — Regular expression operations
- 6.3. difflib — Helpers for computing deltas
- 6.4. textwrap — Text wrapping and filling
- 6.5. unicodedata — Unicode Database
- 6.6. stringprep — Internet String Preparation
- 6.7. readline — GNU readline interface
- 6.8. rlcompleter — Completion function for GNU readline
- 7. Binary Data Services
- 7.1. struct — Interpret bytes as packed binary data
- 7.2. codecs — Codec registry and base classes
- 7.2.1. Codec Base Classes
- 7.2.2. Encodings and Unicode
- 7.2.3. Standard Encodings
- 7.2.4. Python Specific Encodings
- 7.2.5. encodings.idna — Internationalized Domain Names in Applications
- 7.2.6. encodings.mbcs — Windows ANSI codepage
- 7.2.7. encodings.utf_8_sig — UTF-8 codec with BOM signature
- 8. Data Types
- 8.1. datetime — Basic date and time types
- 8.2. calendar — General calendar-related functions
- 8.3. collections — Container datatypes
- 8.4. collections.abc — Abstract Base Classes for Containers
- 8.5. heapq — Heap queue algorithm
- 8.6. bisect — Array bisection algorithm
- 8.7. array — Efficient arrays of numeric values
- 8.8. weakref — Weak references
- 8.9. types — Dynamic type creation and names for built-in types
- 8.10. copy — Shallow and deep copy operations
- 8.11. pprint — Data pretty printer
- 8.12. reprlib — Alternate repr() implementation
- 8.13. enum — Support for enumerations
- 8.13.1. Module Contents
- 8.13.2. Creating an Enum
- 8.13.3. Programmatic access to enumeration members and their attributes
- 8.13.4. Duplicating enum members and values
- 8.13.5. Ensuring unique enumeration values
- 8.13.6. Iteration
- 8.13.7. Comparisons
- 8.13.8. Allowed members and attributes of enumerations
- 8.13.9. Restricted subclassing of enumerations
- 8.13.10. Pickling
- 8.13.11. Functional API
- 8.13.12. Derived Enumerations
- 8.13.13. Interesting examples
- 8.13.14. How are Enums different?
- 9. Numeric and Mathematical Modules
- 9.1. numbers — Numeric abstract base classes
- 9.2. math — Mathematical functions
- 9.3. cmath — Mathematical functions for complex numbers
- 9.4. decimal — Decimal fixed point and floating point arithmetic
- 9.5. fractions — Rational numbers
- 9.6. random — Generate pseudo-random numbers
- 9.7. statistics — Mathematical statistics functions
- 10. Functional Programming Modules
- 11. File and Directory Access
- 11.1. pathlib — Object-oriented filesystem paths
- 11.2. os.path — Common pathname manipulations
- 11.3. fileinput — Iterate over lines from multiple input streams
- 11.4. stat — Interpreting stat() results
- 11.5. filecmp — File and Directory Comparisons
- 11.6. tempfile — Generate temporary files and directories
- 11.7. glob — Unix style pathname pattern expansion
- 11.8. fnmatch — Unix filename pattern matching
- 11.9. linecache — Random access to text lines
- 11.10. shutil — High-level file operations
- 11.11. macpath — Mac OS 9 path manipulation functions
- 12. Data Persistence
- 12.1. pickle — Python object serialization
- 12.2. copyreg — Register pickle support functions
- 12.3. shelve — Python object persistence
- 12.4. marshal — Internal Python object serialization
- 12.5. dbm — Interfaces to Unix “databases”
- 12.6. sqlite3 — DB-API 2.0 interface for SQLite databases
- 13. Data Compression and Archiving
- 14. File Formats
- 14.1. csv — CSV File Reading and Writing
- 14.2. configparser — Configuration file parser
- 14.2.1. Quick Start
- 14.2.2. Supported Datatypes
- 14.2.3. Fallback Values
- 14.2.4. Supported INI File Structure
- 14.2.5. Interpolation of values
- 14.2.6. Mapping Protocol Access
- 14.2.7. Customizing Parser Behaviour
- 14.2.8. Legacy API Examples
- 14.2.9. ConfigParser Objects
- 14.2.10. RawConfigParser Objects
- 14.2.11. Exceptions
- 14.3. netrc — netrc file processing
- 14.4. xdrlib — Encode and decode XDR data
- 14.5. plistlib — Generate and parse Mac OS X .plist files
- 15. Cryptographic Services
- 16. Generic Operating System Services
- 16.1. os — Miscellaneous operating system interfaces
- 16.1.1. File Names, Command Line Arguments, and Environment Variables
- 16.1.2. Process Parameters
- 16.1.3. File Object Creation
- 16.1.4. File Descriptor Operations
- 16.1.5. Files and Directories
- 16.1.6. Process Management
- 16.1.7. Interface to the scheduler
- 16.1.8. Miscellaneous System Information
- 16.1.9. Miscellaneous Functions
- 16.2. io — Core tools for working with streams
- 16.3. time — Time access and conversions
- 16.4. argparse — Parser for command-line options, arguments and sub-commands
- 16.5. getopt — C-style parser for command line options
- 16.6. logging — Logging facility for Python
- 16.6.1. Logger Objects
- 16.6.2. Logging Levels
- 16.6.3. Handler Objects
- 16.6.4. Formatter Objects
- 16.6.5. Filter Objects
- 16.6.6. LogRecord Objects
- 16.6.7. LogRecord attributes
- 16.6.8. LoggerAdapter Objects
- 16.6.9. Thread Safety
- 16.6.10. Module-Level Functions
- 16.6.11. Module-Level Attributes
- 16.6.12. Integration with the warnings module
- 16.7. logging.config — Logging configuration
- 16.8. logging.handlers — Logging handlers
- 16.8.1. StreamHandler
- 16.8.2. FileHandler
- 16.8.3. NullHandler
- 16.8.4. WatchedFileHandler
- 16.8.5. BaseRotatingHandler
- 16.8.6. RotatingFileHandler
- 16.8.7. TimedRotatingFileHandler
- 16.8.8. SocketHandler
- 16.8.9. DatagramHandler
- 16.8.10. SysLogHandler
- 16.8.11. NTEventLogHandler
- 16.8.12. SMTPHandler
- 16.8.13. MemoryHandler
- 16.8.14. HTTPHandler
- 16.8.15. QueueHandler
- 16.8.16. QueueListener
- 16.9. getpass — Portable password input
- 16.10. curses — Terminal handling for character-cell displays
- 16.11. curses.textpad — Text input widget for curses programs
- 16.12. curses.ascii — Utilities for ASCII characters
- 16.13. curses.panel — A panel stack extension for curses
- 16.14. platform — Access to underlying platform’s identifying data
- 16.15. errno — Standard errno system symbols
- 16.16. ctypes — A foreign function library for Python
- 16.16.1. ctypes tutorial
- 16.16.1.1. Loading dynamic link libraries
- 16.16.1.2. Accessing functions from loaded dlls
- 16.16.1.3. Calling functions
- 16.16.1.4. Fundamental data types
- 16.16.1.5. Calling functions, continued
- 16.16.1.6. Calling functions with your own custom data types
- 16.16.1.7. Specifying the required argument types (function prototypes)
- 16.16.1.8. Return types
- 16.16.1.9. Passing pointers (or: passing parameters by reference)
- 16.16.1.10. Structures and unions
- 16.16.1.11. Structure/union alignment and byte order
- 16.16.1.12. Bit fields in structures and unions
- 16.16.1.13. Arrays
- 16.16.1.14. Pointers
- 16.16.1.15. Type conversions
- 16.16.1.16. Incomplete Types
- 16.16.1.17. Callback functions
- 16.16.1.18. Accessing values exported from dlls
- 16.16.1.19. Surprises
- 16.16.1.20. Variable-sized data types
- 16.16.2. ctypes reference
- 16.16.1. ctypes tutorial
- 16.1. os — Miscellaneous operating system interfaces
- 17. Concurrent Execution
- 17.1. threading — Thread-based parallelism
- 17.2. multiprocessing — Process-based parallelism
- 17.2.1. Introduction
- 17.2.2. Reference
- 17.2.2.1. Process and exceptions
- 17.2.2.2. Pipes and Queues
- 17.2.2.3. Miscellaneous
- 17.2.2.4. Connection Objects
- 17.2.2.5. Synchronization primitives
- 17.2.2.6. Shared ctypes Objects
- 17.2.2.7. Managers
- 17.2.2.8. Proxy Objects
- 17.2.2.9. Process Pools
- 17.2.2.10. Listeners and Clients
- 17.2.2.11. Authentication keys
- 17.2.2.12. Logging
- 17.2.2.13. The multiprocessing.dummy module
- 17.2.3. Programming guidelines
- 17.2.4. Examples
- 17.3. The concurrent package
- 17.4. concurrent.futures — Launching parallel tasks
- 17.5. subprocess — Subprocess management
- 17.6. sched — Event scheduler
- 17.7. queue — A synchronized queue class
- 17.8. dummy_threading — Drop-in replacement for the threading module
- 17.9. _thread — Low-level threading API
- 17.10. _dummy_thread — Drop-in replacement for the _thread module
- 18. Interprocess Communication and Networking
- 18.1. socket — Low-level networking interface
- 18.2. ssl — TLS/SSL wrapper for socket objects
- 18.3. select — Waiting for I/O completion
- 18.4. selectors – High-level I/O multiplexing
- 18.5. asyncio – Asynchronous I/O, event loop, coroutines and tasks
- 18.5.1. Base Event Loop
- 18.5.1.1. Run an event loop
- 18.5.1.2. Calls
- 18.5.1.3. Delayed calls
- 18.5.1.4. Tasks
- 18.5.1.5. Creating connections
- 18.5.1.6. Creating listening connections
- 18.5.1.7. Watch file descriptors
- 18.5.1.8. Low-level socket operations
- 18.5.1.9. Resolve host name
- 18.5.1.10. Connect pipes
- 18.5.1.11. UNIX signals
- 18.5.1.12. Executor
- 18.5.1.13. Error Handling API
- 18.5.1.14. Debug mode
- 18.5.1.15. Server
- 18.5.1.16. Handle
- 18.5.1.17. Event loop examples
- 18.5.2. Event loops
- 18.5.3. Tasks and coroutines
- 18.5.4. Transports and protocols (low-level API)
- 18.5.5. Streams (high-level API)
- 18.5.6. Subprocess
- 18.5.7. Synchronization primitives
- 18.5.8. Queues
- 18.5.9. Develop with asyncio
- 18.5.9.1. Debug mode of asyncio
- 18.5.9.2. Cancellation
- 18.5.9.3. Concurrency and multithreading
- 18.5.9.4. Handle blocking functions correctly
- 18.5.9.5. Logging
- 18.5.9.6. Detect coroutine objects never scheduled
- 18.5.9.7. Detect exceptions never consumed
- 18.5.9.8. Chain coroutines correctly
- 18.5.9.9. Pending task destroyed
- 18.5.9.10. Close transports and event loops
- 18.5.1. Base Event Loop
- 18.6. asyncore — Asynchronous socket handler
- 18.7. asynchat — Asynchronous socket command/response handler
- 18.8. signal — Set handlers for asynchronous events
- 18.9. mmap — Memory-mapped file support
- 19. Internet Data Handling
- 19.1. email — An email and MIME handling package
- 19.1.1. email.message: Representing an email message
- 19.1.2. email.parser: Parsing email messages
- 19.1.3. email.generator: Generating MIME documents
- 19.1.4. email.policy: Policy Objects
- 19.1.5. email.headerregistry: Custom Header Objects
- 19.1.6. email.contentmanager: Managing MIME Content
- 19.1.7. email.mime: Creating email and MIME objects from scratch
- 19.1.8. email.header: Internationalized headers
- 19.1.9. email.charset: Representing character sets
- 19.1.10. email.encoders: Encoders
- 19.1.11. email.errors: Exception and Defect classes
- 19.1.12. email.utils: Miscellaneous utilities
- 19.1.13. email.iterators: Iterators
- 19.1.14. email: Examples
- 19.1.15. Package History
- 19.1.16. Differences from mimelib
- 19.2. json — JSON encoder and decoder
- 19.3. mailcap — Mailcap file handling
- 19.4. mailbox — Manipulate mailboxes in various formats
- 19.5. mimetypes — Map filenames to MIME types
- 19.6. base64 — Base16, Base32, Base64, Base85 Data Encodings
- 19.7. binhex — Encode and decode binhex4 files
- 19.8. binascii — Convert between binary and ASCII
- 19.9. quopri — Encode and decode MIME quoted-printable data
- 19.10. uu — Encode and decode uuencode files
- 19.1. email — An email and MIME handling package
- 20. Structured Markup Processing Tools
- 20.1. html — HyperText Markup Language support
- 20.2. html.parser — Simple HTML and XHTML parser
- 20.3. html.entities — Definitions of HTML general entities
- 20.4. XML Processing Modules
- 20.5. xml.etree.ElementTree — The ElementTree XML API
- 20.6. xml.dom — The Document Object Model API
- 20.6.1. Module Contents
- 20.6.2. Objects in the DOM
- 20.6.2.1. DOMImplementation Objects
- 20.6.2.2. Node Objects
- 20.6.2.3. NodeList Objects
- 20.6.2.4. DocumentType Objects
- 20.6.2.5. Document Objects
- 20.6.2.6. Element Objects
- 20.6.2.7. Attr Objects
- 20.6.2.8. NamedNodeMap Objects
- 20.6.2.9. Comment Objects
- 20.6.2.10. Text and CDATASection Objects
- 20.6.2.11. ProcessingInstruction Objects
- 20.6.2.12. Exceptions
- 20.6.3. Conformance
- 20.7. xml.dom.minidom — Minimal DOM implementation
- 20.8. xml.dom.pulldom — Support for building partial DOM trees
- 20.9. xml.sax — Support for SAX2 parsers
- 20.10. xml.sax.handler — Base classes for SAX handlers
- 20.11. xml.sax.saxutils — SAX Utilities
- 20.12. xml.sax.xmlreader — Interface for XML parsers
- 20.13. xml.parsers.expat — Fast XML parsing using Expat
- 21. Internet Protocols and Support
- 21.1. webbrowser — Convenient Web-browser controller
- 21.2. cgi — Common Gateway Interface support
- 21.3. cgitb — Traceback manager for CGI scripts
- 21.4. wsgiref — WSGI Utilities and Reference Implementation
- 21.5. urllib — URL handling modules
- 21.6. urllib.request — Extensible library for opening URLs
- 21.6.1. Request Objects
- 21.6.2. OpenerDirector Objects
- 21.6.3. BaseHandler Objects
- 21.6.4. HTTPRedirectHandler Objects
- 21.6.5. HTTPCookieProcessor Objects
- 21.6.6. ProxyHandler Objects
- 21.6.7. HTTPPasswordMgr Objects
- 21.6.8. AbstractBasicAuthHandler Objects
- 21.6.9. HTTPBasicAuthHandler Objects
- 21.6.10. ProxyBasicAuthHandler Objects
- 21.6.11. AbstractDigestAuthHandler Objects
- 21.6.12. HTTPDigestAuthHandler Objects
- 21.6.13. ProxyDigestAuthHandler Objects
- 21.6.14. HTTPHandler Objects
- 21.6.15. HTTPSHandler Objects
- 21.6.16. FileHandler Objects
- 21.6.17. DataHandler Objects
- 21.6.18. FTPHandler Objects
- 21.6.19. CacheFTPHandler Objects
- 21.6.20. UnknownHandler Objects
- 21.6.21. HTTPErrorProcessor Objects
- 21.6.22. Examples
- 21.6.23. Legacy interface
- 21.6.24. urllib.request Restrictions
- 21.7. urllib.response — Response classes used by urllib
- 21.8. urllib.parse — Parse URLs into components
- 21.9. urllib.error — Exception classes raised by urllib.request
- 21.10. urllib.robotparser — Parser for robots.txt
- 21.11. http — HTTP modules
- 21.12. http.client — HTTP protocol client
- 21.13. ftplib — FTP protocol client
- 21.14. poplib — POP3 protocol client
- 21.15. imaplib — IMAP4 protocol client
- 21.16. nntplib — NNTP protocol client
- 21.17. smtplib — SMTP protocol client
- 21.18. smtpd — SMTP Server
- 21.19. telnetlib — Telnet client
- 21.20. uuid — UUID objects according to RFC 4122
- 21.21. socketserver — A framework for network servers
- 21.22. http.server — HTTP servers
- 21.23. http.cookies — HTTP state management
- 21.24. http.cookiejar — Cookie handling for HTTP clients
- 21.25. xmlrpc — XMLRPC server and client modules
- 21.26. xmlrpc.client — XML-RPC client access
- 21.27. xmlrpc.server — Basic XML-RPC servers
- 21.28. ipaddress — IPv4/IPv6 manipulation library
- 22. Multimedia Services
- 22.1. audioop — Manipulate raw audio data
- 22.2. aifc — Read and write AIFF and AIFC files
- 22.3. sunau — Read and write Sun AU files
- 22.4. wave — Read and write WAV files
- 22.5. chunk — Read IFF chunked data
- 22.6. colorsys — Conversions between color systems
- 22.7. imghdr — Determine the type of an image
- 22.8. sndhdr — Determine type of sound file
- 22.9. ossaudiodev — Access to OSS-compatible audio devices
- 23. Internationalization
- 24. Program Frameworks
- 24.1. turtle — Turtle graphics
- 24.1.1. Introduction
- 24.1.2. Overview of available Turtle and Screen methods
- 24.1.3. Methods of RawTurtle/Turtle and corresponding functions
- 24.1.4. Methods of TurtleScreen/Screen and corresponding functions
- 24.1.5. Public classes
- 24.1.6. Help and configuration
- 24.1.7. turtledemo — Demo scripts
- 24.1.8. Changes since Python 2.6
- 24.1.9. Changes since Python 3.0
- 24.2. cmd — Support for line-oriented command interpreters
- 24.3. shlex — Simple lexical analysis
- 24.1. turtle — Turtle graphics
- 25. Graphical User Interfaces with Tk
- 25.1. tkinter — Python interface to Tcl/Tk
- 25.2. tkinter.ttk — Tk themed widgets
- 25.3. tkinter.tix — Extension widgets for Tk
- 25.4. tkinter.scrolledtext — Scrolled Text Widget
- 25.5. IDLE
- 25.5.1. Menus
- 25.5.1.1. File menu (Shell and Editor)
- 25.5.1.2. Edit menu (Shell and Editor)
- 25.5.1.3. Format menu (Editor window only)
- 25.5.1.4. Run menu (Editor window only)
- 25.5.1.5. Shell menu (Shell window only)
- 25.5.1.6. Debug menu (Shell window only)
- 25.5.1.7. Options menu (Shell and Editor)
- 25.5.1.8. Window menu (Shell and Editor)
- 25.5.1.9. Help menu (Shell and Editor)
- 25.5.1.10. Context Menus
- 25.5.2. Editing and navigation
- 25.5.3. Startup and code execution
- 25.5.4. Help and preferences
- 25.5.1. Menus
- 25.6. Other Graphical User Interface Packages
- 26. Development Tools
- 26.1. pydoc — Documentation generator and online help system
- 26.2. doctest — Test interactive Python examples
- 26.3. unittest — Unit testing framework
- 26.3.1. Basic example
- 26.3.2. Command-Line Interface
- 26.3.3. Test Discovery
- 26.3.4. Organizing test code
- 26.3.5. Re-using old test code
- 26.3.6. Skipping tests and expected failures
- 26.3.7. Distinguishing test iterations using subtests
- 26.3.8. Classes and functions
- 26.3.9. Class and Module Fixtures
- 26.3.10. Signal Handling
- 26.4. unittest.mock — mock object library
- 26.5. unittest.mock — getting started
- 26.5.1. Using Mock
- 26.5.1.1. Mock Patching Methods
- 26.5.1.2. Mock for Method Calls on an Object
- 26.5.1.3. Mocking Classes
- 26.5.1.4. Naming your mocks
- 26.5.1.5. Tracking all Calls
- 26.5.1.6. Setting Return Values and Attributes
- 26.5.1.7. Raising exceptions with mocks
- 26.5.1.8. Side effect functions and iterables
- 26.5.1.9. Creating a Mock from an Existing Object
- 26.5.2. Patch Decorators
- 26.5.3. Further Examples
- 26.5.3.1. Mocking chained calls
- 26.5.3.2. Partial mocking
- 26.5.3.3. Mocking a Generator Method
- 26.5.3.4. Applying the same patch to every test method
- 26.5.3.5. Mocking Unbound Methods
- 26.5.3.6. Checking multiple calls with mock
- 26.5.3.7. Coping with mutable arguments
- 26.5.3.8. Nesting Patches
- 26.5.3.9. Mocking a dictionary with MagicMock
- 26.5.3.10. Mock subclasses and their attributes
- 26.5.3.11. Mocking imports with patch.dict
- 26.5.3.12. Tracking order of calls and less verbose call assertions
- 26.5.3.13. More complex argument matching
- 26.5.1. Using Mock
- 26.6. 2to3 - Automated Python 2 to 3 code translation
- 26.7. test — Regression tests package for Python
- 26.8. test.support — Utilities for the Python test suite
- 27. Debugging and Profiling
- 27.1. bdb — Debugger framework
- 27.2. faulthandler — Dump the Python traceback
- 27.3. pdb — The Python Debugger
- 27.4. The Python Profilers
- 27.5. timeit — Measure execution time of small code snippets
- 27.6. trace — Trace or track Python statement execution
- 27.7. tracemalloc — Trace memory allocations
- 28. Software Packaging and Distribution
- 29. Python Runtime Services
- 29.1. sys — System-specific parameters and functions
- 29.2. sysconfig — Provide access to Python’s configuration information
- 29.3. builtins — Built-in objects
- 29.4. __main__ — Top-level script environment
- 29.5. warnings — Warning control
- 29.6. contextlib — Utilities for with-statement contexts
- 29.6.1. Utilities
- 29.6.2. Examples and Recipes
- 29.6.2.1. Supporting a variable number of context managers
- 29.6.2.2. Simplifying support for single optional context managers
- 29.6.2.3. Catching exceptions from __enter__ methods
- 29.6.2.4. Cleaning up in an __enter__ implementation
- 29.6.2.5. Replacing any use of try-finally and flag variables
- 29.6.2.6. Using a context manager as a function decorator
- 29.6.3. Single use, reusable and reentrant context managers
- 29.7. abc — Abstract Base Classes
- 29.8. atexit — Exit handlers
- 29.9. traceback — Print or retrieve a stack traceback
- 29.10. __future__ — Future statement definitions
- 29.11. gc — Garbage Collector interface
- 29.12. inspect — Inspect live objects
- 29.13. site — Site-specific configuration hook
- 29.14. fpectl — Floating point exception control
- 30. Custom Python Interpreters
- 31. Importing Modules
- 32. Python Language Services
- 32.1. parser — Access Python parse trees
- 32.2. ast — Abstract Syntax Trees
- 32.3. symtable — Access to the compiler’s symbol tables
- 32.4. symbol — Constants used with Python parse trees
- 32.5. token — Constants used with Python parse trees
- 32.6. keyword — Testing for Python keywords
- 32.7. tokenize — Tokenizer for Python source
- 32.8. tabnanny — Detection of ambiguous indentation
- 32.9. pyclbr — Python class browser support
- 32.10. py_compile — Compile Python source files
- 32.11. compileall — Byte-compile Python libraries
- 32.12. dis — Disassembler for Python bytecode
- 32.13. pickletools — Tools for pickle developers
- 33. Miscellaneous Services
- 34. MS Windows Specific Services
- 35. Unix Specific Services
- 35.1. posix — The most common POSIX system calls
- 35.2. pwd — The password database
- 35.3. spwd — The shadow password database
- 35.4. grp — The group database
- 35.5. crypt — Function to check Unix passwords
- 35.6. termios — POSIX style tty control
- 35.7. tty — Terminal control functions
- 35.8. pty — Pseudo-terminal utilities
- 35.9. fcntl — The fcntl and ioctl system calls
- 35.10. pipes — Interface to shell pipelines
- 35.11. resource — Resource usage information
- 35.12. nis — Interface to Sun’s NIS (Yellow Pages)
- 35.13. syslog — Unix syslog library routines
- 36. Superseded Modules
- 36.1. optparse — Parser for command line options
- 36.1.1. Background
- 36.1.2. Tutorial
- 36.1.3. Reference Guide
- 36.1.3.1. Creating the parser
- 36.1.3.2. Populating the parser
- 36.1.3.3. Defining options
- 36.1.3.4. Option attributes
- 36.1.3.5. Standard option actions
- 36.1.3.6. Standard option types
- 36.1.3.7. Parsing arguments
- 36.1.3.8. Querying and manipulating your option parser
- 36.1.3.9. Conflicts between options
- 36.1.3.10. Cleanup
- 36.1.3.11. Other methods
- 36.1.4. Option Callbacks
- 36.1.4.1. Defining a callback option
- 36.1.4.2. How callbacks are called
- 36.1.4.3. Raising errors in a callback
- 36.1.4.4. Callback example 1: trivial callback
- 36.1.4.5. Callback example 2: check option order
- 36.1.4.6. Callback example 3: check option order (generalized)
- 36.1.4.7. Callback example 4: check arbitrary condition
- 36.1.4.8. Callback example 5: fixed arguments
- 36.1.4.9. Callback example 6: variable arguments
- 36.1.5. Extending optparse
- 36.2. imp — Access the import internals
- 36.1. optparse — Parser for command line options
- 37. Undocumented Modules
- Extending and Embedding the Python Interpreter
- Recommended third party tools
- Creating extensions without third party tools
- 1. Extending Python with C or C++
- 1.1. A Simple Example
- 1.2. Intermezzo: Errors and Exceptions
- 1.3. Back to the Example
- 1.4. The Module’s Method Table and Initialization Function
- 1.5. Compilation and Linkage
- 1.6. Calling Python Functions from C
- 1.7. Extracting Parameters in Extension Functions
- 1.8. Keyword Parameters for Extension Functions
- 1.9. Building Arbitrary Values
- 1.10. Reference Counts
- 1.11. Writing Extensions in C++
- 1.12. Providing a C API for an Extension Module
- 2. Defining New Types
- 3. Building C and C++ Extensions with distutils
- 4. Building C and C++ Extensions on Windows
- 1. Extending Python with C or C++
- Embedding the CPython runtime in a larger application
- Python/C API Reference Manual
- Introduction
- Stable Application Binary Interface
- The Very High Level Layer
- Reference Counting
- Exception Handling
- Utilities
- Abstract Objects Layer
- Concrete Objects Layer
- Initialization, Finalization, and Threads
- Memory Management
- Object Implementation Support
- API and ABI Versioning
- Distributing Python Modules
- Installing Python Modules
- 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
- 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
- Curses Programming with Python
- Descriptor HowTo Guide
- Functional Programming HOWTO
- Logging HOWTO
- 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
- 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
- Configuring filters with dictConfig()
- Customized exception formatting
- Speaking logging messages
- Buffering logging messages and outputting them conditionally
- Formatting times using UTC (GMT) via configuration
- Regular Expression HOWTO
- Socket Programming HOWTO
- Sorting HOW TO
- Unicode HOWTO
- HOWTO Fetch Internet Resources Using The urllib Package
- HOWTO Use Python in the web
- Argparse Tutorial
- An introduction to the ipaddress module
- 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
- Porting Python 2 Code to Python 3
- Python Frequently Asked Questions
- General Python FAQ
- Programming FAQ
- 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
- 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
- “Why is Python Installed on my Computer?” FAQ
- Glossary
- About these documents
- Reporting Bugs
- Copyright
- History and License
Navigation
- index
- modules |
- next |
- Python »
- 3.4.4 Documentation »