documentation.HELP! IronPython Documentation

12. Data Compression and Archiving

IronPython

previous page next page

Navigation

  • index
  • modules |
  • next |
  • previous |
  • IronPython v2.7.4a1 documentation »
  • The Python Standard Library »

12. Data Compression and Archiving

The modules described in this chapter support data compression with the zlib, gzip, and bzip2 algorithms, and the creation of ZIP- and tar-format archives.

  • 12.1. zlib — Compression compatible with gzip
  • 12.2. gzip — Support for gzip files
    • 12.2.1. Examples of usage
  • 12.3. bz2 — Compression compatible with bzip2
    • 12.3.1. (De)compression of files
    • 12.3.2. Sequential (de)compression
    • 12.3.3. One-shot (de)compression
  • 12.4. zipfile — Work with ZIP archives
    • 12.4.1. ZipFile Objects
    • 12.4.2. PyZipFile Objects
    • 12.4.3. ZipInfo Objects
  • 12.5. tarfile — Read and write tar archive files
    • 12.5.1. TarFile Objects
    • 12.5.2. TarInfo Objects
    • 12.5.3. Examples
    • 12.5.4. Supported tar formats
    • 12.5.5. Unicode issues

Navigation

  • index
  • modules |
  • next |
  • previous |
  • IronPython v2.7.4a1 documentation »
  • The Python Standard Library »
© Copyright 1990-2013, Python Software Foundation.
The Python Software Foundation is a non-profit corporation. Please donate.
Last updated on May 10, 2013. Found a bug?
Created using Sphinx 0.6.3.
previous page start next page

Menu

  • Homepage

Table of contents

  • IronPython v2.7.4a1 documentation
  • Global Module Index
  • What's New in Python
    • What's New in Python 2.7
      • The Future for Python 2.x
      • 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
      • Acknowledgements
    • What's New in Python 2.6
      • Python 3.0
        • 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 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 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 future_builtins module
        • The json module: JavaScript Object Notation
        • The plistlib module: A Property-List Parser
        • ctypes Enhancements
        • Improved SSL Support
      • Deprecations and Removals
      • Acknowledgements
    • What's New in Python 2.5 (IronPython 2.0)
      • 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 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
        • Port-Specific Changes
      • Porting to IronPython 2.0
      • Acknowledgements
  • The Python Tutorial
    • Whetting Your Appetite
    • Using the Python Interpreter
      • Invoking the Interpreter
        • Argument Passing
        • Interactive Mode
      • The Interpreter and Its Environment
        • Error Handling
        • Executable Python Scripts
        • Source Code Encoding
        • The Interactive Startup File
    • An Informal Introduction to Python
      • Using Python as a Calculator
        • Numbers
        • Strings
        • Unicode 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 Forms
        • Documentation Strings
      • Intermezzo: Coding Style
    • Data Structures
      • More on Lists
        • Using Lists as Stacks
        • Using Lists as Queues
        • Functional Programming Tools
        • 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
        • The pickle Module
    • 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
      • A First Look at Classes
        • Class Definition Syntax
        • Class Objects
        • Instance Objects
        • Method Objects
      • 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
    • What Now?
    • Interactive Input Editing and History Substitution
      • Line Editing
      • History Substitution
      • Key Bindings
      • Alternatives to the Interactive Interpreter
    • Floating Point Arithmetic: Issues and Limitations
      • Representation Error
  • Using Python
    • Command line and environment
      • Command line
        • Interface options
        • Generic options
        • Miscellaneous options
        • Options you shouldn't use
      • Environment variables
        • Debug-mode variables
  • 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 literals
        • String literal concatenation
        • Numeric literals
        • Integer and long integer literals
        • Floating point literals
        • Imaginary literals
      • Operators
      • Delimiters
    • Data model
      • Objects, values and types
      • The standard type hierarchy
      • New-style and classic classes
      • Special method names
        • Basic customization
        • Customizing attribute access
          • More attribute access for new-style classes
          • Implementing Descriptors
          • Invoking Descriptors
          • __slots__
        • Customizing class creation
        • Customizing instance and subclass checks
        • Emulating callable objects
        • Emulating container types
        • Additional methods for emulation of sequence types
        • Emulating numeric types
        • Coercion rules
        • With Statement Context Managers
        • Special method lookup for old-style classes
        • Special method lookup for new-style classes
    • Execution model
      • Naming and binding
        • Interaction with dynamic features
      • Exceptions
    • Expressions
      • Arithmetic conversions
      • Atoms
        • Identifiers (Names)
        • Literals
        • Parenthesized forms
        • List displays
        • Displays for sets and dictionaries
        • Generator expressions
        • Dictionary displays
        • Set displays
        • String conversions
        • Yield expressions
      • Primaries
        • Attribute references
        • Subscriptions
        • Slicings
        • Calls
      • 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
      • Summary
    • Simple statements
      • Expression statements
      • Assignment statements
        • Augmented assignment statements
      • The assert statement
      • The pass statement
      • The del statement
      • The print 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 exec statement
    • Compound statements
      • The if statement
      • The while statement
      • The for statement
      • The try statement
      • The with statement
      • Function definitions
      • Class definitions
    • Top-level components
      • Complete Python programs
      • File input
      • Interactive input
      • Expression input
    • Full Grammar specification
  • The Python Standard Library
    • Introduction
    • Built-in Functions
    • Non-essential 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, long, complex
        • Bit-string Operations on Integer Types
        • Additional Methods on Integer Types
        • Additional Methods on Float
      • Iterator Types
        • Generator Types
      • Sequence Types --- str, unicode, list, tuple, buffer, xrange
        • String Methods
        • String Formatting Operations
        • XRange Type
        • Mutable Sequence Types
      • Set Types --- set, frozenset
      • Mapping Types --- dict
        • Dictionary view objects
      • File Objects
      • memoryview type
      • Context Manager Types
      • Other Built-in Types
        • Modules
        • Classes and Class Instances
        • Functions
        • Methods
        • Code Objects
        • Type Objects
        • The Null Object
        • The Ellipsis Object
        • Boolean Values
        • Internal Objects
      • Special Attributes
    • Built-in Exceptions
      • Exception hierarchy
    • String Services
      • string --- Common string operations
        • String constants
        • String Formatting
        • Format String Syntax
          • Format Specification Mini-Language
          • Format examples
        • Template strings
        • String functions
        • Deprecated string functions
      • re --- Regular expression operations
        • Regular Expression Syntax
        • Matching vs Searching
        • Module Contents
        • Regular Expression Objects
        • Match Objects
        • Examples
          • Checking For a Pair
          • Simulating scanf()
          • Avoiding recursion
          • search() vs. match()
          • Making a Phonebook
          • Text Munging
          • Finding all Adverbs
          • Finding all Adverbs and their Positions
          • Raw String Notation
      • struct --- Interpret strings as packed binary data
        • Functions and Exceptions
        • Format Strings
          • Byte Order, Size, and Alignment
          • Format Characters
          • Examples
        • Classes
      • difflib --- Helpers for computing deltas
        • SequenceMatcher Objects
        • SequenceMatcher Examples
        • Differ Objects
        • Differ Example
        • A command-line interface to difflib
      • StringIO --- Read and write strings as files
      • cStringIO --- Faster version of StringIO
      • textwrap --- Text wrapping and filling
      • codecs --- Codec registry and base classes
        • Codec Base Classes
          • Codec Objects
          • IncrementalEncoder Objects
          • IncrementalDecoder Objects
          • StreamWriter Objects
          • StreamReader Objects
          • StreamReaderWriter Objects
          • StreamRecoder Objects
        • Encodings and Unicode
        • Standard Encodings
        • encodings.idna --- Internationalized Domain Names in Applications
        • encodings.utf_8_sig --- UTF-8 codec with BOM signature
      • unicodedata --- Unicode Database
      • stringprep --- Internet String Preparation
      • fpformat --- Floating point conversions
    • Data Types
      • datetime --- Basic date and time types
        • Available Types
        • timedelta Objects
        • date Objects
        • datetime Objects
        • time Objects
        • tzinfo Objects
        • strftime() and strptime() Behavior
      • calendar --- General calendar-related functions
      • collections --- High-performance container datatypes
        • ABCs - abstract base classes
        • Counter objects
        • deque objects
          • deque Recipes
        • defaultdict objects
          • defaultdict Examples
        • namedtuple() Factory Function for Tuples with Named Fields
        • OrderedDict objects
      • heapq --- Heap queue algorithm
        • Theory
      • bisect --- Array bisection algorithm
        • Examples
      • array --- Efficient arrays of numeric values
      • sets --- Unordered collections of unique elements
        • Set Objects
        • Example
        • Protocol for automatic conversion to immutable
        • Comparison to the built-in set types
      • sched --- Event scheduler
        • Scheduler Objects
      • mutex --- Mutual exclusion support
        • Mutex Objects
      • queue --- A synchronized queue class
        • Queue Objects
      • weakref --- Weak references
        • Weak Reference Objects
        • Example
      • UserDict --- Class wrapper for dictionary objects
      • UserList --- Class wrapper for list objects
      • UserString --- Class wrapper for string objects
      • types --- Names for built-in types
      • new --- Creation of runtime internal objects
      • copy --- Shallow and deep copy operations
      • pprint --- Data pretty printer
        • PrettyPrinter Objects
        • pprint Example
      • repr --- Alternate repr() implementation
        • Repr Objects
        • Subclassing Repr Objects
    • 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
        • 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
      • itertools --- Functions creating iterators for efficient looping
        • Itertool functions
        • Recipes
      • functools --- Higher order functions and operations on callable objects
        • partial Objects
      • operator --- Standard operators as functions
        • Mapping Operators to Functions
    • File and Directory Access
      • os.path --- Common pathname manipulations
      • fileinput --- Iterate over lines from multiple input streams
      • stat --- Interpreting stat() results
      • statvfs --- Constants used with os.statvfs()
      • filecmp --- File and Directory Comparisons
        • The dircmp class
      • 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
        • Directory and files operations
          • copytree example
        • Archives operations
          • Archiving example
      • dircache --- Cached directory listings
    • Data Persistence
      • pickle --- Python object serialization
        • Relationship to other Python modules
        • Data stream format
        • Usage
        • What can be pickled and unpickled?
        • The pickle protocol
          • Pickling and unpickling normal class instances
          • Pickling and unpickling extension types
          • Pickling and unpickling external objects
        • Subclassing Unpicklers
        • Example
      • cPickle --- A faster pickle
      • copy_reg --- Register pickle support functions
      • shelve --- Python object persistence
        • Restrictions
        • Example
      • marshal --- Internal Python object serialization
      • anydbm --- Generic access to DBM-style databases
      • whichdb --- Guess which DBM module created a database
      • dbhash --- DBM-style interface to the BSD database library
        • Database Objects
      • dumbdbm --- Portable DBM implementation
        • Dumbdbm Objects
      • 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
    • Data Compression and Archiving
      • zlib --- Compression compatible with gzip
      • gzip --- Support for gzip files
        • Examples of usage
      • bz2 --- Compression compatible with bzip2
        • (De)compression of files
        • Sequential (de)compression
        • One-shot (de)compression
      • zipfile --- Work with ZIP archives
        • ZipFile Objects
        • PyZipFile Objects
        • ZipInfo Objects
      • tarfile --- Read and write tar archive files
        • TarFile Objects
        • TarInfo Objects
        • 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
        • RawConfigParser Objects
        • ConfigParser Objects
        • SafeConfigParser Objects
        • Examples
      • robotparser --- Parser for robots.txt
      • 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
      • hmac --- Keyed-Hashing for Message Authentication
      • md5 --- MD5 message digest algorithm
      • sha --- SHA-1 message digest algorithm
    • Generic Operating System Services
      • os --- Miscellaneous operating system interfaces
        • Process Parameters
        • File Object Creation
        • File Descriptor Operations
          • open() flag constants
        • Files and Directories
        • Process Management
        • Miscellaneous System Information
        • Miscellaneous Functions
      • io --- Core tools for working with streams
        • Module Interface
        • I/O Base Classes
        • Raw File I/O
        • Buffered Streams
        • Text I/O
      • 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
          • description
          • epilog
          • add_help
          • prefix_chars
          • fromfile_prefix_chars
          • argument_default
          • parents
          • formatter_class
          • conflict_handler
          • prog
          • usage
        • The add_argument() method
          • name or flags
          • action
          • nargs
          • const
          • default
          • type
          • choices
          • required
          • help
          • metavar
          • dest
        • The parse_args() method
          • Option value syntax
          • Invalid arguments
          • Arguments containing "-"
          • Argument abbreviations
          • Beyond sys.argv
          • Custom namespaces
        • Other utilities
          • Sub-commands
          • FileType objects
          • Argument groups
          • Mutual exclusion
          • Parser defaults
          • Printing help
          • Partial parsing
          • Customizing file parsing
        • Upgrading optparse code
      • 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
          • 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
      • getopt --- C-style parser for command line options
      • logging --- Logging facility for Python
        • Logging tutorial
          • Simple examples
          • Loggers
          • Handlers
          • Formatters
          • Configuring Logging
          • Configuring Logging for a Library
        • Logging Levels
        • Useful Handlers
        • Module-Level Functions
        • Logger Objects
        • Basic example
        • Logging to multiple destinations
        • Exceptions raised during logging
        • Adding contextual information to your logging output
        • Logging to a single file from multiple processes
        • Sending and receiving logging events across a network
        • Using arbitrary objects as messages
        • Optimization
        • Handler Objects
          • StreamHandler
          • FileHandler
          • NullHandler
          • WatchedFileHandler
          • RotatingFileHandler
          • TimedRotatingFileHandler
          • SocketHandler
          • DatagramHandler
          • SysLogHandler
          • NTEventLogHandler
          • SMTPHandler
          • MemoryHandler
          • HTTPHandler
        • Formatter Objects
        • Filter Objects
        • LogRecord Objects
        • LoggerAdapter Objects
        • Thread Safety
        • Integration with the warnings module
        • Configuration
          • Configuration functions
          • Configuration dictionary schema
            • Dictionary Schema Details
            • Incremental Configuration
            • Object connections
            • User-defined objects
            • Access to external objects
            • Access to internal objects
          • Configuration file format
          • Configuration server example
        • More examples
          • Multiple handlers and formatters
          • Using logging in multiple modules
      • 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.wrapper --- Terminal handler for curses programs
      • 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
    • Optional Operating System Services
      • select --- Waiting for I/O completion
        • Edge and Level Trigger Polling (epoll) Objects
        • Polling Objects
        • Kqueue Objects
        • Kevent Objects
      • threading --- Higher-level threading interface
        • Thread Objects
        • Lock Objects
        • RLock Objects
        • Condition Objects
        • Semaphore Objects
          • Semaphore Example
        • Event Objects
        • Timer Objects
        • Using locks, conditions, and semaphores in the with statement
        • Importing in threaded code
      • thread --- Multiple threads of control
      • dummy_threading --- Drop-in replacement for the threading module
      • dummy_thread --- Drop-in replacement for the thread module
      • multiprocessing --- Process-based "threading" interface
        • Introduction
          • The Process class
          • 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 platforms
          • Windows
        • Examples
      • rlcompleter --- Completion function for GNU readline
        • Completer Objects
    • Interprocess Communication and Networking
      • subprocess --- Subprocess management
        • Using the subprocess Module
          • Convenience Functions
          • Exceptions
          • Security
        • Popen Objects
        • 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
      • socket --- Low-level networking interface
        • Socket Objects
        • Example
      • ssl --- SSL wrapper for socket objects
        • Functions, Constants, and Exceptions
        • SSLSocket Objects
        • Certificates
        • Examples
          • Testing for SSL support
          • Client-side operation
          • Server-side operation
      • signal --- Set handlers for asynchronous events
        • Example
      • popen2 --- Subprocesses with accessible I/O streams
        • Popen3 and Popen4 Objects
        • Flow Control Issues
      • asyncore --- Asynchronous socket handler
        • asyncore Example basic HTTP client
      • asynchat --- Asynchronous socket command/response handler
        • asynchat - Auxiliary Classes
        • asynchat Example
    • Internet Data Handling
      • email --- An email and MIME handling package
        • email: Representing an email message
        • email: Parsing email messages
          • FeedParser API
          • Parser class API
          • Additional notes
        • 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
        • Basic Usage
        • Encoders and decoders
      • 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
        • Deprecated classes and methods
        • Examples
      • mhlib --- Access to MH mailboxes
        • MH Objects
        • Folder Objects
        • Message Objects
      • mimetools --- Tools for parsing MIME messages
        • Additional Methods of Message Objects
      • mimetypes --- Map filenames to MIME types
        • MimeTypes Objects
      • MimeWriter --- Generic MIME file writer
        • MimeWriter Objects
      • mimify --- MIME processing of mail messages
      • multifile --- Support for files containing distinct parts
        • MultiFile Objects
        • MultiFile Example
      • rfc822 --- Parse RFC 2822 mail headers
        • Message Objects
        • AddressList Objects
      • base64 --- RFC 3548: Base16, Base32, Base64 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
      • HTMLParser --- Simple HTML and XHTML parser
        • Example HTML Parser Application
      • sgmllib --- Simple SGML parser
      • htmllib --- A parser for HTML documents
        • HTMLParser Objects
      • htmlentitydefs --- Definitions of HTML general entities
      • xml.parsers.expat --- Fast XML parsing using Expat
        • XMLParser Objects
        • ExpatError Exceptions
        • Example
        • Content Model Descriptions
        • Expat error constants
      • 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 --- Lightweight 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.etree.ElementTree --- The ElementTree XML API
        • Functions
        • Element Objects
        • ElementTree Objects
        • QName Objects
        • TreeBuilder Objects
        • XMLParser Objects
    • 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
        • Old classes
        • 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 --- Open arbitrary resources by URL
        • High-level interface
        • Utility functions
        • URL Opener objects
        • urllib Restrictions
        • Examples
      • urllib2 --- 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
      • httplib --- HTTP protocol client
        • HTTPConnection Objects
        • HTTPResponse Objects
        • Examples
      • 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
      • smtplib --- SMTP protocol client
        • SMTP Objects
        • SMTP Example
      • smtpd --- SMTP Server
        • SMTPServer Objects
        • DebuggingServer Objects
        • PureProxy Objects
        • MailmanProxy Objects
      • telnetlib --- Telnet client
        • Telnet Objects
        • Telnet Example
      • uuid --- UUID objects according to RFC 4122
        • Example
      • urlparse --- Parse URLs into components
        • Results of urlparse() and urlsplit()
      • SocketServer --- A framework for network servers
        • Server Creation Notes
        • Server Objects
        • RequestHandler Objects
        • Examples
          • SocketServer.TCPServer Example
          • SocketServer.UDPServer Example
          • Asynchronous Mixins
      • BaseHTTPServer --- Basic HTTP server
        • More examples
      • SimpleHTTPServer --- Simple HTTP request handler
      • CGIHTTPServer --- CGI-capable HTTP request handler
      • cookielib --- Cookie handling for HTTP clients
        • CookieJar and FileCookieJar Objects
        • FileCookieJar subclasses and co-operation with web browsers
        • CookiePolicy Objects
        • DefaultCookiePolicy Objects
        • Cookie Objects
        • Examples
      • Cookie --- HTTP state management
        • Cookie Objects
        • Morsel Objects
        • Example
      • xmlrpclib --- XML-RPC client access
        • ServerProxy Objects
        • Boolean Objects
        • DateTime Objects
        • Binary Objects
        • Fault Objects
        • ProtocolError Objects
        • MultiCall Objects
        • Convenience Functions
        • Example of Client Usage
        • Example of Client and Server Usage
      • SimpleXMLRPCServer --- Basic XML-RPC server
        • SimpleXMLRPCServer Objects
          • SimpleXMLRPCServer Example
        • CGIXMLRPCRequestHandler
      • DocXMLRPCServer --- Self-documenting XML-RPC server
        • DocXMLRPCServer Objects
        • DocCGIXMLRPCRequestHandler
    • Multimedia Services
      • audioop --- Manipulate raw audio data
      • imageop --- Manipulate raw image 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
    • 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
          • gettext() vs. lgettext()
        • Acknowledgements
      • locale --- Internationalization services
        • Background, details, hints, tips and caveats
        • For extension writers and programs that embed Python
        • Access to message catalogs
    • Program Frameworks
      • cmd --- Support for line-oriented command interpreters
        • Cmd Objects
      • shlex --- Simple lexical analysis
        • shlex Objects
        • Parsing Rules
    • Development Tools
      • 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 and 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
          • failfast, catch and buffer command line options
        • Test Discovery
        • Organizing test code
        • Re-using old test code
        • Skipping tests and expected failures
        • Classes and functions
          • Test cases
          • Grouping tests
          • Loading and running tests
            • load_tests Protocol
        • Class and Module Fixtures
          • setUpClass and tearDownClass
          • setUpModule and tearDownModule
        • Signal Handling
      • 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 test.regrtest
      • test.test_support --- Utility functions for tests
    • Debugging and Profiling
      • bdb --- Debugger framework
      • pdb --- The Python Debugger
      • Debugger Commands
      • The Python Profilers
        • Introduction to the profilers
        • Instant User's Manual
        • What Is Deterministic Profiling?
        • Reference Manual -- profile and cProfile
          • The Stats Class
        • Limitations
        • Calibration
        • Extensions --- Deriving Better Profilers
      • hotshot --- High performance logging profiler
        • Profile Objects
        • Using hotshot data
        • Example Usage
      • timeit --- Measure execution time of small code snippets
        • Command Line Interface
        • Examples
      • trace --- Trace or track Python statement execution
        • Command Line Usage
        • Programming Interface
    • Python Runtime Services
      • sys --- System-specific parameters and functions
      • sysconfig --- Provide access to Python's configuration information
        • Configuration variables
        • Installation paths
        • Other functions
      • __builtin__ --- Built-in objects
      • future_builtins --- Python 3 builtins
      • __main__ --- Top-level script environment
      • warnings --- Warning control
        • Warning Categories
        • The Warnings Filter
        • Temporarily Suppressing Warnings
        • Testing Warnings
        • Updating Code For New Versions of Python
        • Available Functions
        • Available Context Managers
      • contextlib --- Utilities for with-statement contexts
      • abc --- Abstract Base Classes
      • atexit --- Exit handlers
        • atexit Example
      • traceback --- Print or retrieve a stack traceback
        • Traceback Examples
      • __future__ --- Future statement definitions
      • gc --- Garbage Collector interface
      • inspect --- Inspect live objects
        • Types and members
        • Retrieving source code
        • Classes and functions
        • The interpreter stack
      • site --- Site-specific configuration hook
      • user --- User-specific configuration hook
      • distutils --- Building and installing Python modules
    • Custom Python Interpreters
      • code --- Interpreter base classes
        • Interactive Interpreter Objects
        • Interactive Console Objects
      • codeop --- Compile Python code
    • Restricted Execution
      • rexec --- Restricted execution framework
        • RExec Objects
        • Defining restricted environments
        • An example
      • Bastion --- Restricting access to objects
    • Importing Modules
      • imp --- Access the import internals
        • Examples
      • importlib -- Convenience wrappers for __import__()
      • imputil --- Import utilities
        • Examples
      • 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
    • Python Language Services
      • parser --- Access Python parse trees
        • Creating ST Objects
        • Converting ST Objects
        • Queries on ST Objects
        • Exceptions and Error Handling
        • ST Objects
        • Examples
          • Emulation of compile()
          • Information Discovery
      • 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
      • 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
      • dis --- Disassembler for Python bytecode
        • Python Bytecode Instructions
      • pickletools --- Tools for pickle developers
    • Python compiler package
      • The basic interface
      • Limitations
      • Python Abstract Syntax
        • AST Nodes
        • Assignment nodes
        • Examples
      • Using Visitors to Walk ASTs
      • Bytecode Generation
    • Miscellaneous Services
      • formatter --- Generic output formatting
        • The Formatter Interface
        • Formatter Implementations
        • The Writer Interface
        • Writer Implementations
    • MS Windows Specific Services
      • _winreg -- Windows registry access
        • Constants
          • HKEY_* Constants
          • Access Rights
            • 64-bit Specific
          • Value Types
        • Registry Handle Objects
    • Undocumented Modules
      • Miscellaneous useful utilities
      • Platform specific modules
      • Multimedia
      • Obsolete
      • SGI-specific Extension modules
  • IronPython Hosting
    • Getting Started
      • Introduction
      • Samples
        • Hello World
        • Calling Python from C#
        • Exposing Application Object Model
      • Reference
    • DLR Hosting APIs
      • DLR Hosting Overview
        • High-level Hosting Model Concepts
        • Level One -- Script Runtimes, Scopes, and Executing Files and Snippets
          • Code Sample -- Application Programmability
        • Level Two -- Engines, Compiled Code, Sources, and Object Operations
          • Code Sample -- REPL and Merlin Web
        • Level Three -- Full Control, Remoting, Tool Support, and More
      • ScriptRuntime
        • ScriptRuntime Members
      • ScriptScope
        • ScriptScope Members
      • ScriptEngine
        • ScriptEngine Members
      • ScriptSource
        • ScriptSource Members
      • ObjectOperations
        • ObjectOperations Members
      • SourceCodeKind
        • Members
      • ScriptCodeParseResult
        • Members
      • CompiledCode
        • CompiledCode Members
      • ScriptRuntimeSetup
        • ScriptRuntimeSetup Members
        • Configuration Structure
        • Default DLR Configuration
      • LanguageSetup
        • LanguageSetup Members
      • ExceptionOperations
        • ExceptionOperations Members
      • ScriptIO
        • ScriptIO Members
      • ScriptHost
        • ScriptHost Members
      • PlatformAdaptionLayer
        • PlatformAdaptionLayer Members
    • .NET Interop
  • Distributing Python Modules
    • An Introduction to Distutils
      • Concepts & Terminology
      • A Simple Example
      • General Python terminology
      • Distutils-specific terminology
    • Writing the Setup Script
      • Listing whole packages
      • Listing individual modules
      • Describing extension modules
        • Extension names and packages
        • Extension source files
        • Preprocessor options
        • Library options
        • Other options
      • Relationships between Distributions and Packages
      • Installing Scripts
      • Installing Package Data
      • Installing Additional Files
      • Additional meta-data
      • Debugging the setup script
    • Writing the Setup Configuration File
    • Creating a Source Distribution
      • Specifying the files to distribute
      • Manifest-related options
      • The MANIFEST.in template
        • Principle
        • Commands
    • Creating Built Distributions
      • Creating dumb built distributions
      • Creating RPM packages
      • Creating Windows Installers
      • Cross-compiling on Windows
        • The Postinstallation script
      • Vista User Access Control (UAC)
    • Registering with the Package Index
      • The .pypirc file
    • Uploading Packages to the Package Index
      • PyPI package display
    • Examples
      • Pure Python distribution (by module)
      • Pure Python distribution (by package)
      • Single extension module
    • Extending Distutils
      • Integrating new commands
      • Adding new distribution types
    • Command Reference
      • Installing modules: the install command family
        • install_data
        • install_scripts
    • 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
      • Creating a new Distutils command
  • Installing Python Modules
    • Introduction
      • Best case: trivial installation
      • The new standard: Distutils
    • Standard Build and Install
      • Platform variations
      • Splitting the job up
      • How building works
      • How installation works
    • Alternate Installation
      • Alternate installation: the home scheme
      • Alternate installation: Unix (the prefix scheme)
      • Alternate installation: Windows (the prefix scheme)
    • Custom Installation
      • Modifying Python's Search Path
    • Distutils Configuration Files
      • Location and names of config files
      • Syntax of config files
    • Building Extensions: Tips and Tricks
      • Tweaking compiler/linker flags
      • Using non-Microsoft compilers on Windows
        • Borland/CodeGear C++
        • GNU C / Cygwin / MinGW
  • Documenting Python
    • Introduction
    • Style Guide
    • reStructuredText Primer
      • Paragraphs
      • Inline markup
      • Lists and Quotes
      • Source Code
      • Hyperlinks
        • External links
        • Internal links
      • Sections
      • Explicit Markup
      • Directives
      • Footnotes
      • Comments
      • Source encoding
      • Gotchas
    • Additional Markup Constructs
      • Meta-information markup
      • Module-specific markup
      • Information units
      • Showing code examples
      • Inline markup
      • Cross-linking markup
      • Paragraph-level markup
      • Table-of-contents markup
      • Index-generating markup
      • Grammar production displays
      • Substitutions
    • Differences to the LaTeX markup
      • Inline markup
      • Information units
      • Structure
    • Building the documentation
      • Using make
      • Without make
  • Python HOWTOs
    • Python Advocacy HOWTO
      • Reasons to Use Python
        • Programmability
        • Prototyping
        • Simplicity and Ease of Understanding
        • Java Integration
      • Arguments and Rebuttals
      • Useful Resources
    • Porting Extension Modules to 3.0
      • Conditional compilation
      • Changes to Object APIs
        • str/unicode Unification
        • long/int Unification
      • Module initialization and state
      • 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
    • Idioms and Anti-Idioms in Python
      • Language Constructs You Should Not Use
        • from module import *
          • Inside Function Definitions
          • At Module Level
          • When It Is Just Fine
        • Unadorned exec, execfile() and friends
        • from module import name1, name2
        • except:
      • Exceptions
      • Using the Batteries
      • Using Backslash to Continue Statements
    • 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
      • Small functions and the lambda expression
      • The itertools module
        • Creating new iterators
        • Calling functions on elements
        • Selecting elements
        • Grouping elements
      • The functools module
        • The operator module
        • The functional module
      • Revision History and Acknowledgements
      • References
        • General
        • Python-specific
        • Python documentation
    • 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
        • Not 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
        • Performance
    • 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 2.x's Unicode Support
        • The Unicode Type
        • Unicode Literals in Python Source Code
        • Unicode Properties
        • References
      • Reading and Writing Unicode Data
        • Unicode filenames
        • Tips for Writing Unicode-aware Programs
        • References
      • Revision History and Acknowledgements
    • HOWTO Fetch Internet Resources Using urllib2
      • 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
  • IronPython .NET API Reference Manual
    • Extending IronPython with C#
      • A Simple Example
    • Parsing and Tokenizing
  • Python Frequently Asked Questions
    • General Python FAQ
      • General Information
      • Python in the real world
      • Upgrading Python
    • Programming FAQ
      • General Questions
      • Core Language
      • Numbers and strings
      • 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 forms contain statements?
      • Can Python be compiled to machine code, C or some other language?
      • How does Python manage memory?
      • Why isn't all memory freed when Python 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 are default values shared between objects?
      • 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)?
      • When importing module X, why do I get "undefined symbol: PyUnicodeUCS2*"?
    • 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?
      • Where is Freeze for Windows?
      • Is a *.pyd file the same as a DLL?
      • How can I embed Python into a Windows application?
      • How do I use Python for CGI?
      • 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?
      • Why does os.path.isdir() fail on NT shared directories?
      • cgi.py (or other CGI programming) doesn't work sometimes on NT or win95!
      • Why doesn't os.popen() work in PythonWin on NT?
      • Why doesn't os.popen()/win32pipe.popen() work on Win9x?
      • PyRun_SimpleFile() crashes on Windows but not on Unix; why?
      • Importing _tkinter fails on Windows 95/98: why?
      • How do I extract the downloaded documentation on Windows?
      • Missing cw3215mt.dll (or missing cw3215.dll)
      • Warning about CTL3D32 version from installer
    • Graphic User Interface FAQ
      • 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
  • Copyright
  • History and License
    • History of the IronPython
    • History of Python
    • IronPython License
    • Terms and conditions for accessing or otherwise using Python
    • Licenses and Acknowledgements for Incorporated Software
      • Mersenne Twister
      • Sockets
      • Floating point exception control
      • MD5 message digest algorithm
      • Asynchronous socket services
      • Cookie management
      • Profiling
      • Execution tracing
      • UUencode and UUdecode functions
      • XML Remote Procedure Calls
      • test_epoll
      • Select kqueue
      • strtod and dtoa

Get in touch

Submit feedback about this site to:

  • [email protected]

© documentation.help. Design: rehmann.co.