ActivePython User Guide
What's New
- What's new in Python 3.1?
- What's new in Python 3.0?
- What's new in Python 2.6?
- What's new in Python 2.5?
- Contents
- 1 PEP 308: Conditional Expressions
- 2 PEP 309: Partial Function Application
- 3 PEP 314: Metadata for Python Software Packages v1.1
- 4 PEP 328: Absolute and Relative Imports
- 5 PEP 338: Executing Modules as Scripts
- 6 PEP 341: Unified try/except/finally
- 7 PEP 342: New Generator Features
- 8 PEP 343: The 'with' statement
- 9 PEP 352: Exceptions as New-Style Classes
- 10 PEP 353: Using ssize_t as the index type
- 11 PEP 357: The '__index__' method
- 12 Other Language Changes
- 13 New, Improved, and Removed Modules
- 14 Build and C API Changes
- 15 Porting to Python 2.5
- 16 Acknowledgements
- About this document ...
- What's new in Python 2.4?
- Contents
- 1 PEP 218: Built-In Set Objects
- 2 PEP 237: Unifying Long Integers and Integers
- 3 PEP 289: Generator Expressions
- 4 PEP 292: Simpler String Substitutions
- 5 PEP 318: Decorators for Functions and Methods
- 6 PEP 322: Reverse Iteration
- 7 PEP 324: New subprocess Module
- 8 PEP 327: Decimal Data Type
- 9 PEP 328: Multi-line Imports
- 10 PEP 331: Locale-Independent Float/String Conversions
- 11 Other Language Changes
- 12 New, Improved, and Deprecated Modules
- 13 Build and C API Changes
- 14 Porting to Python 2.4
- 15 Acknowledgements
- About this document ...
- What's new in Python 2.3?
- Contents
- 1 PEP 218: A Standard Set Datatype
- 2 PEP 255: Simple Generators
- 3 PEP 263: Source Code Encodings
- 4 PEP 273: Importing Modules from Zip Archives
- 5 PEP 277: Unicode file name support for Windows NT
- 6 PEP 278: Universal Newline Support
- 7 PEP 279: enumerate()
- 8 PEP 282: The logging Package
- 9 PEP 285: A Boolean Type
- 10 PEP 293: Codec Error Handling Callbacks
- 11 PEP 301: Package Index and Metadata for Distutils
- 12 PEP 302: New Import Hooks
- 13 PEP 305: Comma-separated Files
- 14 PEP 307: Pickle Enhancements
- 15 Extended Slices
- 16 Other Language Changes
- 17 New, Improved, and Deprecated Modules
- 18 Pymalloc: A Specialized Object Allocator
- 19 Build and C API Changes
- 20 Other Changes and Fixes
- 21 Porting to Python 2.3
- 22 Acknowledgements
- About this document ...
- What's new in Python 2.2?
- What's new in Python 2.1?
- What's new in Python 2.0?
- The NEWS file
- The HISTORY file
Python Documentation
- Python v3.1.1 documentation
- Global Module Index
- What's New in Python
- What's New In Python 3.1
- What's New In Python 3.0
- What's New in Python 2.7
- 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, Improved, and Deprecated Modules
- 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
- The Python Tutorial
- Whetting Your Appetite
- Using the Python Interpreter
- An Informal Introduction to Python
- More Control Flow Tools
- Data Structures
- Modules
- Input and Output
- Errors and Exceptions
- Classes
- Brief Tour of the Standard Library
- Brief Tour of the Standard Library -- Part II
- What Now?
- Interactive Input Editing and History Substitution
- Floating Point Arithmetic: Issues and Limitations
- Using Python
- The Python Language Reference
- Introduction
- Lexical analysis
- Data model
- Execution model
- Expressions
- Simple statements
- Compound statements
- Top-level components
- Full Grammar specification
- The Python Standard Library
- Introduction
- Built-in Functions
- Built-in Constants
- Built-in Objects
- Built-in Types
- Truth Value Testing
- Boolean Operations --- and, or, not
- Comparisons
- Numeric Types --- int, float, complex
- Iterator Types
- Sequence Types --- str, bytes, bytearray, list, tuple, range
- Set Types --- set, frozenset
- Mapping Types --- dict
- File Objects
- memoryview Types
- Context Manager Types
- Other Built-in Types
- Special Attributes
- Built-in Exceptions
- String Services
- string --- Common string operations
- re --- Regular expression operations
- struct --- Interpret bytes as packed binary data
- difflib --- Helpers for computing deltas
- textwrap --- Text wrapping and filling
- codecs --- Codec registry and base classes
- unicodedata --- Unicode Database
- stringprep --- Internet String Preparation
- Data Types
- datetime --- Basic date and time types
- calendar --- General calendar-related functions
- collections --- Container datatypes
- heapq --- Heap queue algorithm
- bisect --- Array bisection algorithm
- array --- Efficient arrays of numeric values
- sched --- Event scheduler
- queue --- A synchronized queue class
- weakref --- Weak references
- types --- Names for built-in types
- copy --- Shallow and deep copy operations
- pprint --- Data pretty printer
- reprlib --- Alternate repr() implementation
- Numeric and Mathematical Modules
- numbers --- Numeric abstract base classes
- math --- Mathematical functions
- cmath --- Mathematical functions for complex numbers
- decimal --- Decimal fixed point and floating point arithmetic
- fractions --- Rational numbers
- random --- Generate pseudo-random numbers
- itertools --- Functions creating iterators for efficient looping
- functools --- Higher order functions and operations on callable objects
- operator --- Standard operators as functions
- File and Directory Access
- os.path --- Common pathname manipulations
- fileinput --- Iterate over lines from multiple input streams
- stat --- Interpreting stat() results
- filecmp --- File and Directory Comparisons
- tempfile --- Generate temporary files and directories
- glob --- Unix style pathname pattern expansion
- fnmatch --- Unix filename pattern matching
- linecache --- Random access to text lines
- shutil --- High-level file operations
- macpath --- Mac OS 9 path manipulation functions
- Data Persistence
- pickle --- Python object serialization
- copyreg --- Register pickle support functions
- shelve --- Python object persistence
- marshal --- Internal Python object serialization
- dbm --- Interfaces to Unix "databases"
- sqlite3 --- DB-API 2.0 interface for SQLite databases
- Data Compression and Archiving
- File Formats
- Cryptographic Services
- Generic Operating System Services
- os --- Miscellaneous operating system interfaces
- io --- Core tools for working with streams
- time --- Time access and conversions
- optparse --- More powerful command line option parser
- Background
- Tutorial
- Reference Guide
- 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
- getopt --- Parser for command line options
- logging --- Logging facility for Python
- Logging tutorial
- Logging Levels
- Useful Handlers
- Module-Level Functions
- Logger Objects
- Basic example
- Logging to multiple destinations
- Adding contextual information to your logging output
- Sending and receiving logging events across a network
- Handler Objects
- Formatter Objects
- Filter Objects
- LogRecord Objects
- LoggerAdapter Objects
- Thread Safety
- Configuration
- More examples
- getpass --- Portable password input
- curses --- Terminal handling for character-cell displays
- curses.textpad --- Text input widget for curses programs
- curses.wrapper --- Terminal handler for curses programs
- curses.ascii --- Utilities for ASCII characters
- curses.panel --- A panel stack extension for curses
- platform --- Access to underlying platform's identifying data
- 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
- ctypes tutorial
- Optional Operating System Services
- select --- Waiting for I/O completion
- threading --- Higher-level threading interface
- dummy_threading --- Drop-in replacement for the threading module
- _thread --- Low-level threading API
- _dummy_thread --- Drop-in replacement for the _thread module
- multiprocessing --- Process-based "threading" interface
- mmap --- Memory-mapped file support
- readline --- GNU readline interface
- rlcompleter --- Completion function for GNU readline
- Interprocess Communication and Networking
- subprocess --- Subprocess management
- socket --- Low-level networking interface
- ssl --- SSL wrapper for socket objects
- signal --- Set handlers for asynchronous events
- asyncore --- Asynchronous socket handler
- asynchat --- Asynchronous socket command/response handler
- Internet Data Handling
- email --- An email and MIME handling package
- email: Representing an email message
- email: Parsing email messages
- email: Generating MIME documents
- email: Creating email and MIME objects from scratch
- email: Internationalized headers
- email: Representing character sets
- email: Encoders
- email: Exception and Defect classes
- email: Miscellaneous utilities
- email: Iterators
- email: Examples
- Package History
- Differences from mimelib
- json --- JSON encoder and decoder
- mailcap --- Mailcap file handling
- mailbox --- Manipulate mailboxes in various formats
- mimetypes --- Map filenames to MIME types
- base64 --- RFC 3548: Base16, Base32, Base64 Data Encodings
- binhex --- Encode and decode binhex4 files
- binascii --- Convert between binary and ASCII
- quopri --- Encode and decode MIME quoted-printable data
- uu --- Encode and decode uuencode files
- email --- An email and MIME handling package
- Structured Markup Processing Tools
- html.parser --- Simple HTML and XHTML parser
- html.entities --- Definitions of HTML general entities
- xml.parsers.expat --- Fast XML parsing using Expat
- xml.dom --- The Document Object Model API
- xml.dom.minidom --- Lightweight DOM implementation
- xml.dom.pulldom --- Support for building partial DOM trees
- xml.sax --- Support for SAX2 parsers
- xml.sax.handler --- Base classes for SAX handlers
- xml.sax.saxutils --- SAX Utilities
- xml.sax.xmlreader --- Interface for XML parsers
- xml.etree.ElementTree --- The ElementTree XML API
- Internet Protocols and Support
- webbrowser --- Convenient Web-browser controller
- cgi --- Common Gateway Interface support
- cgitb --- Traceback manager for CGI scripts
- wsgiref --- WSGI Utilities and Reference Implementation
- urllib.request --- extensible library for opening URLs
- Request Objects
- OpenerDirector Objects
- BaseHandler Objects
- HTTPRedirectHandler Objects
- HTTPCookieProcessor Objects
- ProxyHandler Objects
- HTTPPasswordMgr Objects
- AbstractBasicAuthHandler Objects
- HTTPBasicAuthHandler Objects
- ProxyBasicAuthHandler Objects
- AbstractDigestAuthHandler Objects
- HTTPDigestAuthHandler Objects
- ProxyDigestAuthHandler Objects
- HTTPHandler Objects
- HTTPSHandler Objects
- FileHandler Objects
- FTPHandler Objects
- CacheFTPHandler Objects
- UnknownHandler Objects
- HTTPErrorProcessor Objects
- Examples
- urllib.request Restrictions
- urllib.response --- Response classes used by urllib.
- urllib.parse --- Parse URLs into components
- urllib.error --- Exception classes raised by urllib.request
- urllib.robotparser --- Parser for robots.txt
- http.client --- HTTP protocol client
- ftplib --- FTP protocol client
- poplib --- POP3 protocol client
- imaplib --- IMAP4 protocol client
- nntplib --- NNTP protocol client
- smtplib --- SMTP protocol client
- smtpd --- SMTP Server
- telnetlib --- Telnet client
- uuid --- UUID objects according to RFC 4122
- socketserver --- A framework for network servers
- http.server --- HTTP servers
- http.cookies --- HTTP state management
- http.cookiejar --- Cookie handling for HTTP clients
- xmlrpc.client --- XML-RPC client access
- xmlrpc.server --- Basic XML-RPC servers
- Multimedia Services
- audioop --- Manipulate raw audio data
- aifc --- Read and write AIFF and AIFC files
- sunau --- Read and write Sun AU files
- wave --- Read and write WAV files
- 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
- Internationalization
- Program Frameworks
- Graphical User Interfaces with Tk
- tkinter --- Python interface to Tcl/Tk
- tkinter.ttk --- Tk themed widgets
- tkinter.tix --- Extension widgets for Tk
- tkinter.scrolledtext --- Scrolled Text Widget
- turtle --- Turtle graphics for Tk
- Introduction
- Overview over available Turtle and Screen methods
- Methods of RawTurtle/Turtle and corresponding functions
- Methods of TurtleScreen/Screen and corresponding functions
- The public classes of the module turtle
- Help and configuration
- Demo scripts
- Changes since Python 2.6
- Changes since Python 3.0
- IDLE
- Other Graphical User Interface Packages
- Development Tools
- pydoc --- Documentation generator and online help system
- doctest --- Test interactive Python examples
- unittest --- Unit testing framework
- 2to3 - Automated Python 2 to 3 code translation
- test --- Regression tests package for Python
- test.support --- Utility functions for tests
- Debugging and Profiling
- Python Runtime Services
- sys --- System-specific parameters and functions
- builtins --- Built-in objects
- __main__ --- Top-level script environment
- warnings --- Warning control
- contextlib --- Utilities for with-statement contexts
- abc --- Abstract Base Classes
- atexit --- Exit handlers
- traceback --- Print or retrieve a stack traceback
- __future__ --- Future statement definitions
- gc --- Garbage Collector interface
- inspect --- Inspect live objects
- site --- Site-specific configuration hook
- fpectl --- Floating point exception control
- Custom Python Interpreters
- Importing Modules
- Python Language Services
- parser --- Access Python parse trees
- Abstract Syntax Trees
- symtable --- Access to the compiler's 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
- tabnanny --- Detection of ambiguous indentation
- pyclbr --- Python class browser support
- py_compile --- Compile Python source files
- compileall --- Byte-compile Python libraries
- dis --- Disassembler for Python bytecode
- pickletools --- Tools for pickle developers
- distutils --- Building and installing Python modules
- Miscellaneous Services
- MS Windows Specific Services
- Unix Specific Services
- posix --- The most common POSIX system calls
- pwd --- The password database
- spwd --- The shadow password database
- grp --- The group database
- crypt --- Function to check Unix passwords
- termios --- POSIX style tty control
- tty --- Terminal control functions
- pty --- Pseudo-terminal utilities
- fcntl --- The fcntl() and ioctl() system calls
- pipes --- Interface to shell pipelines
- resource --- Resource usage information
- nis --- Interface to Sun's NIS (Yellow Pages)
- syslog --- Unix syslog library routines
- Undocumented Modules
- Extending and Embedding the Python Interpreter
- 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
- Writing Extensions in C++
- Providing a C API for an Extension Module
- Defining New Types
- Building C and C++ Extensions with distutils
- Building C and C++ Extensions on Windows
- Embedding Python in Another Application
- Extending Python with C or C++
- Python/C API Reference Manual
- Introduction
- 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
- Distributing Python Modules
- An Introduction to Distutils
- Writing the Setup Script
- Writing the Setup Configuration File
- Creating a Source Distribution
- Creating Built Distributions
- Registering with the Package Index
- Uploading Packages to the Package Index
- Examples
- Extending Distutils
- Command Reference
- API Reference
- distutils.core --- Core Distutils functionality
- distutils.ccompiler --- CCompiler base class
- distutils.unixccompiler --- Unix C Compiler
- distutils.msvccompiler --- Microsoft Compiler
- distutils.bcppcompiler --- Borland Compiler
- distutils.cygwincompiler --- Cygwin Compiler
- distutils.emxccompiler --- OS/2 EMX Compiler
- distutils.archive_util --- Archiving utilities
- distutils.dep_util --- Dependency checking
- distutils.dir_util --- Directory tree operations
- distutils.file_util --- Single file operations
- distutils.util --- Miscellaneous other utility functions
- distutils.dist --- The Distribution class
- distutils.extension --- The Extension class
- distutils.debug --- Distutils debug mode
- distutils.errors --- Distutils exceptions
- distutils.fancy_getopt --- Wrapper around the standard getopt module
- distutils.filelist --- The FileList class
- distutils.log --- Simple PEP 282-style logging
- distutils.spawn --- Spawn a sub-process
- distutils.sysconfig --- System configuration information
- distutils.text_file --- The TextFile class
- distutils.version --- Version number classes
- distutils.cmd --- Abstract base class for Distutils commands
- distutils.command --- Individual Distutils commands
- distutils.command.bdist --- Build a binary installer
- distutils.command.bdist_packager --- Abstract base class for packagers
- distutils.command.bdist_dumb --- Build a "dumb" installer
- distutils.command.bdist_msi --- Build a Microsoft Installer binary package
- distutils.command.bdist_rpm --- Build a binary distribution as a Redhat RPM and SRPM
- distutils.command.bdist_wininst --- Build a Windows installer
- distutils.command.sdist --- Build a source distribution
- distutils.command.build --- Build all files of a package
- distutils.command.build_clib --- Build any C libraries in a package
- distutils.command.build_ext --- Build any extensions in a package
- distutils.command.build_py --- Build the .py/.pyc files of a package
- distutils.command.build_scripts --- Build the scripts of a package
- distutils.command.clean --- Clean a package build area
- distutils.command.config --- Perform package configuration
- distutils.command.install --- Install a package
- distutils.command.install_data --- Install data files from a package
- distutils.command.install_headers --- Install C/C++ header files from a package
- distutils.command.install_lib --- Install library files from a package
- distutils.command.install_scripts --- Install script files from a package
- distutils.command.register --- Register a module with the Python Package Index
- distutils.command.check --- Check the meta-data of a package
- Creating a new Distutils command
- Installing Python Modules
- Documenting Python
- Python HOWTOs
- Python Advocacy HOWTO
- Porting Extension Modules to 3.0
- Curses Programming with Python
- Idioms and Anti-Idioms in Python
- Functional Programming HOWTO
- Regular Expression HOWTO
- Socket Programming HOWTO
- Unicode HOWTO
- HOWTO Fetch Internet Resources Using The urllib Package
- HOWTO Use Python in the web
- Glossary
- About these documents
- Reporting Bugs in Python
- Copyright
- History and License
Helpful Resources
- Non-Programmer's Tutorial for Python
- Front Matter
- Contents
- Intro
- Hello, World
- Who Goes There?
- Count to 10
- Decisions
- Debugging
- Defining Functions
- Lists
- For Loops
- Boolean Expressions
- Dictionaries
- Using Modules
- More on Lists
- Revenge of the Strings
- File IO
- Dealing with the imperfect (or how to handle errors)
- The End
- FAQ
- About this document ...
- Dive Into Python
- 1. Installing Python
- 2. Your First Python Program
- 3. Native Datatypes
- 4. The Power Of Introspection
- 5. Objects and Object-Orientation
- 6. Exceptions and File Handling
- 7. Regular Expressions
- 8. HTML Processing
- 9. XML Processing
- 10. Scripts and Streams
- 11. HTTP Web Services
- 12. SOAP Web Services
- 13. Unit Testing
- 14. Test-First Programming
- 15. Refactoring
- 16. Functional Programming
- 17. Dynamic functions
- 18. Performance Tuning
- A. Further reading
- B. A 5-minute review
- C. Tips and tricks
- D. List of examples
- E. Revision history
- F. About the book
- G. GNU Free Documentation License
- G.0. Preamble
- G.1. Applicability and definitions
- G.2. Verbatim copying
- G.3. Copying in quantity
- G.4. Modifications
- G.5. Combining documents
- G.6. Collections of documents
- G.7. Aggregation with independent works
- G.8. Translation
- G.9. Termination
- G.10. Future revisions of this license
- G.11. How to use this License for your documents
- H. Python license
- Python FAQs
- Python Enhancement Proposals (PEPs)
- PEP 0 -- Index of Python Enhancement Proposals (PEPs)
- PEP 1 -- PEP Purpose and Guidelines
- PEP 2 -- Procedure for Adding New Modules
- PEP 3 -- Guidelines for Handling Bug Reports
- PEP 4 -- Deprecation of Standard Modules
- PEP 5 -- Guidelines for Language Evolution
- PEP 6 -- Bug Fix Releases
- PEP 7 -- Style Guide for C Code
- PEP 8 -- Style Guide for Python Code
- PEP 9 -- Sample Plaintext PEP Template
- PEP 10 -- Voting Guidelines
- PEP 11 -- Removing support for little used platforms
- PEP 12 -- Sample reStructuredText PEP Template
- PEP 20 -- The Zen of Python
- PEP 42 -- Feature Requests
- PEP 100 -- Python Unicode Integration
- PEP 101 -- Doing Python Releases 101
- PEP 102 -- Doing Python Micro Releases
- PEP 160 -- Python 1.6 Release Schedule
- PEP 200 -- Python 2.0 Release Schedule
- PEP 201 -- Lockstep Iteration
- PEP 202 -- List Comprehensions
- PEP 203 -- Augmented Assignments
- PEP 204 -- Range Literals
- PEP 205 -- Weak References
- PEP 206 -- Python Advanced Library
- PEP 207 -- Rich Comparisons
- PEP 208 -- Reworking the Coercion Model
- PEP 209 -- Multi-dimensional Arrays
- PEP 210 -- Decoupling the Interpreter Loop
- PEP 211 -- Adding A New Outer Product Operator
- PEP 212 -- Loop Counter Iteration
- PEP 213 -- Attribute Access Handlers
- PEP 214 -- Extended Print Statement
- PEP 215 -- String Interpolation
- PEP 216 -- Docstring Format
- PEP 217 -- Display Hook for Interactive Use
- PEP 218 -- Adding a Built-In Set Object Type
- PEP 219 -- Stackless Python
- PEP 220 -- Coroutines, Generators, Continuations
- PEP 221 -- Import As
- PEP 222 -- Web Library Enhancements
- PEP 223 -- Change the Meaning of \x Escapes
- PEP 224 -- Attribute Docstrings
- PEP 225 -- Elementwise/Objectwise Operators
- PEP 226 -- Python 2.1 Release Schedule
- PEP 227 -- Statically Nested Scopes
- PEP 228 -- Reworking Python's Numeric Model
- PEP 229 -- Using Distutils to Build Python
- PEP 230 -- Warning Framework
- PEP 231 -- __findattr__()
- PEP 232 -- Function Attributes
- PEP 233 -- Python Online Help
- PEP 234 -- Iterators
- PEP 235 -- Import on Case-Insensitive Platforms
- PEP 236 -- Back to the __future__
- PEP 237 -- Unifying Long Integers and Integers
- PEP 238 -- Changing the Division Operator
- PEP 239 -- Adding a Rational Type to Python
- PEP 240 -- Adding a Rational Literal to Python
- PEP 241 -- Metadata for Python Software Packages
- PEP 242 -- Numeric Kinds
- PEP 243 -- Module Repository Upload Mechanism
- PEP 244 -- The `directive' statement
- PEP 245 -- Python Interface Syntax
- PEP 246 -- Object Adaptation
- PEP 247 -- API for Cryptographic Hash Functions
- PEP 248 -- Python Database API Specification v1.0
- PEP 249 -- Python Database API Specification v2.0
- PEP 250 -- Using site-packages on Windows
- PEP 251 -- Python 2.2 Release Schedule
- PEP 252 -- Making Types Look More Like Classes
- PEP 253 -- Subtyping Built-in Types
- PEP 254 -- Making Classes Look More Like Types
- PEP 255 -- Simple Generators
- PEP 256 -- Docstring Processing System Framework
- PEP 257 -- Docstring Conventions
- PEP 258 -- Docutils Design Specification
- PEP 259 -- Omit printing newline after newline
- PEP 260 -- Simplify xrange()
- PEP 261 -- Support for "wide" Unicode characters
- PEP 262 -- A Database of Installed Python Packages
- PEP 0263 -- Defining Python Source Code Encodings
- PEP 264 -- Future statements in simulated shells
- PEP 265 -- Sorting Dictionaries by Value
- PEP 266 -- Optimizing Global Variable/Attribute Access
- PEP 267 -- Optimized Access to Module Namespaces
- PEP 268 -- Extended HTTP functionality and WebDAV
- PEP 269 -- Pgen Module for Python
- PEP 270 -- uniq method for list objects
- PEP 271 -- Prefixing sys.path by command line option
- PEP 272 -- API for Block Encryption Algorithms v1.0
- PEP 273 -- Import Modules from Zip Archives
- PEP 274 -- Dict Comprehensions
- PEP 0275 -- Switching on Multiple Values
- PEP 276 -- Simple Iterator for ints
- PEP 277 -- Unicode file name support for Windows NT
- PEP 278 -- Universal Newline Support
- PEP 279 -- The enumerate() built-in function
- PEP 280 -- Optimizing access to globals
- PEP 281 -- Loop Counter Iteration with range and xrange
- PEP 282 -- A Logging System
- PEP 283 -- Python 2.3 Release Schedule
- PEP 284 -- Integer for-loops
- PEP 285 -- Adding a bool type
- PEP 286 -- Enhanced Argument Tuples
- PEP 287 -- reStructuredText Docstring Format
- PEP 288 -- Generators Attributes and Exceptions
- PEP 289 -- Generator Expressions
- PEP 290 -- Code Migration and Modernization
- PEP 291 -- Backward Compatibility for Standard Library
- PEP 292 -- Simpler String Substitutions
- PEP 293 -- Codec Error Handling Callbacks
- PEP 294 -- Type Names in the types Module
- PEP 295 -- Interpretation of multiline string constants
- PEP 296 -- Adding a bytes Object Type
- PEP 297 -- Support for System Upgrades
- PEP 298 -- The Locked Buffer Interface
- PEP 299 -- Special __main__() function in modules
- PEP 301 -- Package Index and Metadata for Distutils
- PEP 302 -- New Import Hooks
- PEP 303 -- Extend divmod() for Multiple Divisors
- PEP 304 -- Controlling Generation of Bytecode Files
- PEP 305 -- CSV File API
- PEP 306 -- How to Change Python's Grammar
- PEP 307 -- Extensions to the pickle protocol
- PEP 308 -- Conditional Expressions
- PEP 309 -- Partial Function Application
- PEP 310 -- Reliable Acquisition/Release Pairs
- PEP 311 -- Simplified Global Interpreter Lock Acquisition for Extensions
- PEP 312 -- Simple Implicit Lambda
- PEP 313 -- Adding Roman Numeral Literals to Python
- PEP 314 -- Metadata for Python Software Packages v1.1
- PEP 315 -- Enhanced While Loop
- PEP 316 -- Programming by Contract for Python
- PEP 317 -- Eliminate Implicit Exception Instantiation
- PEP 318 -- Decorators for Functions and Methods
- PEP 319 -- Python Synchronize/Asynchronize Block
- PEP 320 -- Python 2.4 Release Schedule
- PEP 321 -- Date/Time Parsing and Formatting
- PEP 322 -- Reverse Iteration
- PEP 323 -- Copyable Iterators
- PEP 324 -- subprocess - New process module
- PEP 325 -- Resource-Release Support for Generators
- PEP 326 -- A Case for Top and Bottom Values
- PEP 327 -- Decimal Data Type
- PEP 328 -- Imports: Multi-Line and Absolute/Relative
- PEP 329 -- Treating Builtins as Constants in the Standard Library
- PEP 330 -- Python Bytecode Verification
- PEP 331 -- Locale-Independent Float/String Conversions
- PEP 332 -- Byte vectors and String/Unicode Unification
- PEP 333 -- Python Web Server Gateway Interface v1.0
- PEP 334 -- Simple Coroutines via SuspendIteration
- PEP 335 -- Overloadable Boolean Operators
- PEP 336 -- Make None Callable
- PEP 337 -- Logging Usage in the Standard Library
- PEP 338 -- Executing modules as scripts
- PEP 339 -- Design of the CPython Compiler
- PEP 340 -- Anonymous Block Statements
- PEP 341 -- Unifying try-except and try-finally
- PEP 342 -- Coroutines via Enhanced Generators
- PEP 343 -- The "with" Statement
- PEP 344 -- Exception Chaining and Embedded Tracebacks
- PEP 345 -- Metadata for Python Software Packages 1.2
- PEP 346 -- User Defined ("with") Statements
- PEP 347 -- Migrating the Python CVS to Subversion
- PEP 348 -- Exception Reorganization for Python 3.0
- PEP 349 -- Allow str() to return unicode strings
- PEP 350 -- Codetags
- PEP 351 -- The freeze protocol
- PEP 352 -- Required Superclass for Exceptions
- PEP 353 -- Using ssize_t as the index type
- PEP 354 -- Enumerations in Python
- PEP 355 -- Path - Object oriented filesystem paths
- PEP 356 -- Python 2.5 Release Schedule
- PEP 357 -- Allowing Any Object to be Used for Slicing
- PEP 358 -- The "bytes" Object
- PEP 359 -- The "make" Statement
- PEP 360 -- Externally Maintained Packages
- PEP 361 -- Python 2.6 and 3.0 Release Schedule
- PEP 362 -- Function Signature Object
- PEP 363 -- Syntax For Dynamic Attribute Access
- PEP 364 -- Transitioning to the Py3K Standard Library
- PEP 365 -- Adding the pkg_resources module
- PEP 366 -- Main module explicit relative imports
- PEP 367 -- New Super
- PEP 368 -- Standard image protocol and class
- PEP 369 -- Post import hooks
- PEP 370 -- Per user site-packages directory
- PEP 371 -- Addition of the multiprocessing package to the standard library
- PEP 372 -- Adding an ordered dictionary to collections
- PEP 666 -- Reject Foolish Indentation
- PEP 754 -- IEEE 754 Floating Point Special Values
- PEP 3000 -- Python 3000
- PEP 3001 -- Procedure for reviewing and improving standard library modules
- PEP 3002 -- Procedure for Backwards-Incompatible Changes
- PEP 3099 -- Things that will Not Change in Python 3000
- PEP 3100 -- Miscellaneous Python 3.0 Plans
- PEP 3101 -- Advanced String Formatting
- PEP 3102 -- Keyword-Only Arguments
- PEP 3103 -- A Switch/Case Statement
- PEP 3104 -- Access to Names in Outer Scopes
- PEP 3105 -- Make print a function
- PEP 3106 -- Revamping dict.keys(), .values() and .items()
- PEP 3107 -- Function Annotations
- PEP 3108 -- Standard Library Reorganization
- PEP 3109 -- Raising Exceptions in Python 3000
- PEP 3110 -- Catching Exceptions in Python 3000
- PEP 3111 -- Simple input built-in in Python 3000
- PEP 3112 -- Bytes literals in Python 3000
- PEP 3113 -- Removal of Tuple Parameter Unpacking
- PEP 3114 -- Renaming iterator.next() to iterator.__next__()
- PEP 3115 -- Metaclasses in Python 3000
- PEP 3116 -- New I/O
- PEP 3117 -- Postfix type declarations
- PEP 3118 -- Revising the buffer protocol
- PEP 3119 -- Introducing Abstract Base Classes
- PEP 3120 -- Using UTF-8 as the default source encoding
- PEP 3121 -- Extension Module Initialization and Finalization
- PEP 3122 -- Delineation of the main module
- PEP 3123 -- Making PyObject_HEAD conform to standard C
- PEP 3124 -- Overloading, Generic Functions, Interfaces, and Adaptation
- PEP 3125 -- Remove Backslash Continuation
- PEP 3126 -- Remove Implicit String Concatenation
- PEP 3127 -- Integer Literal Support and Syntax
- PEP 3128 -- BList: A Faster List-like Type
- PEP 3129 -- Class Decorators
- PEP 3130 -- Access to Current Module/Class/Function
- PEP 3131 -- Supporting Non-ASCII Identifiers
- PEP 3132 -- Extended Iterable Unpacking
- PEP 3133 -- Introducing Roles
- PEP 3134 -- Exception Chaining and Embedded Tracebacks
- PEP 3135 -- New Super
- PEP 3136 -- Labeled break and continue
- PEP 3137 -- Immutable Bytes and Mutable Buffer
- PEP 3138 -- String representation in Python 3000
- PEP 3139 -- Cleaning out sys and the "interpreter" module
- PEP 3140 -- str(container) should call str(item), not repr(item)
- PEP 3141 -- A Type Hierarchy for Numbers