Python 2.1 Bible

Sections

Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Jumping In: Starting the Python Interpreter
CHAPTER
Jumping in: Starting the Python interpreter
Experimenting with Variables and Expressions
Pocket calculator
Variables
Defining a Function
Running a Python Program
Looping and Control
Integer division
Looping
Branching with if-statements
Breaking and continuing
Lists and Tuples
Tuples
Slicing and dicing
Dictionaries
Reading and Writing Files
Sample Program: Word Frequencies
Loading and Using Modules
Creating a Class
Some quick object jargon
Object orientation, Python style
Keep off the grass—Accessing class members
Example: the point class
Recommended Reading
Identifiers and Operators
Identifiers and operators
Reserved words
Operators
Numeric Types
Integers
Long integers
Floating point numbers
Imaginary numbers
Manipulating numeric types
Assigning Values to Variables
Simple assignment statements
Multiple assignment
Augmented assignment
Expressions
Comparing numeric types
Compound expressions
Complex expressions
Operator precedence
Strings
String literals
Manipulating strings
Comparing strings
Unicode string literals
Converting Between Simple Types
Converting to numerical types
Converting to strings
Grouping Data with Sequences
Grouping data with sequences
Creating lists
Creating tuples
Working with Sequences
Joining and repeating with arithmetic operators
Comparing and membership testing
Accessing parts of sequences
Iterating with for...in
Using sequence utility functions
Using Additional List Object Features
Additional operations
List object methods
Mapping Information with Dictionaries
Creating and adding to dictionaries
Accessing and updating dictionary mappings
Additional dictionary operations
Understanding References
Object identity
Counting references
Copying Complex Objects
Shallow copies
Deep copies
Identifying Data Types
Working with Array Objects
Creating arrays
Converting between types
Array methods and operations
Making Decisions with If-Statements
Making decisions with if-statements
Using For-Loops
Anatomy of a for-loop
Looping example: encoding strings
Ranges and xranges
Breaking, continuing, and else-clauses
Changing horses in midstream
Using While-Loops
Throwing and Catching Exceptions
Passing the buck: propagating exceptions
Handling an exception
More on exceptions
Defining and raising exceptions
Cleaning up with finally
Debugging with Assertions
Assertions in Python
Toggling assertions
Example: Game of Life
Defining Functions
Defining functions
Pass by object reference
All about parameters
Arbitrary arguments
Apply: passing arguments from a tuple
A bit of functional programming
Grouping Code with Modules
Laying out a module
Taking inventory of a module
Importing Modules
What else happens upon import?
Reimporting modules
Exotic imports
Locating Modules
Python path
Compiled files
Understanding Scope Rules
Is it local or global?
Listing namespace contents
Grouping Modules into Packages
Compiling and Running Programmatically
Overview of Object-Oriented Python
Overview of object- oriented Python
Creating Classes and Instance Objects
Creating instance objects
More on accessing attributes
Deriving New Classes from Other Classes
Multiple inheritance
Creating a custom list class
Creating a custom string class
Creating a custom dictionary class
Hiding Private Data
Identifying Class Membership
Overloading Standard Behaviors
Overloading basic functionality
Overloading numeric operators
Overloading sequence and dictionary operators
Overloading bitwise operators
Overloading type conversions
Using Weak References
Creating weak references
Creating proxy objects
Printing to the Screen
Printing to the screen
Accessing Keyboard Input
raw_input
input
Opening, Closing, and Positioning Files
open
File object information
close
File position
Writing Files
Reading Files
Accessing Standard I/O
Using Filelike Objects
Using String Objects
Using string objects
String formatting methods
String case-changing methods
String format tests (the is-methods)
String searching methods
String manipulation methods
Using the String Module
Character categories
Miscellaneous functions
Defining Regular Expressions
Regular expression syntax
Backslashes and raw strings
Character groups and other backslash magic
Nongreedy matching
Extensions
Creating and Using Regular Expression Objects
Using regular expression objects
Applying regular expressions without compiling
Using Match Objects
group([groupid,...])
groups([nomatch])
groupdict([nomatch])
start([groupid]), end([groupid]), span([groupid])
Treating Strings as Files
Encoding Text
Using Unicode strings
Reading and writing non-ASCII strings
Using the Unicode database
Formatting Floating Point Numbers
fix(number,precision)
sci(number,precision)
Retrieving File and Directory Information
Retrieving file and directory information
The piecemeal approach
The I-want-it-all approach
Building and Dissecting Paths
Joining path parts
Breaking paths into pieces
Other path modifiers
Listing Directories and Matching File Names
Obtaining Environment and Argument Information
Environment variables
Current working directory
Command-line parameters
Example: Recursive Grep Utility
Copying, Renaming, and Removing Paths
Copying and linking
Renaming
Removing
Creating Directories and Temporary Files
Comparing Files and Directories
Working with File Descriptors
General file descriptor functions
Pipes
Other File Processing Techniques
Randomly accessing lines in text files
Using memory-mapped files
Iterating over several files
Executing Shell Commands and Other Programs
Executing shell commands and other programs
Spawning Child Processes
popen functions
spawn functions
fork
Process management and termination
Handling Process Information
Retrieving System Information
Managing Configuration Files
Understanding Error Names
Handling Asynchronous Signals
Data Storage Overview
Text versus binary
Data storage overview
Compression
Byte order (“Endianness”)
Object state
Destination
On the receiving end
Loading and Saving Objects
Pickling with pickle
The marshal module
Example: Moving Objects Across a Network
Using Database-Like Storage
Converting to and from C Structures
Converting Data to Standard Formats
Sun’s XDR format
Other formats
Compressing Data
zlib
gzip
zipfile
Telling Time in Python
Ticks
Telling time in Python
TimeTuple
Stopwatch time
Converting Between Time Formats
Parsing and Printing Dates and Times
Fancy formatting
Parsing time
Localization
Accessing the Calendar
Printing monthly and yearly calendars
Calendar information
Leap years
Using Time Zones
Allowing Two-Digit Years
Using Disk-Based Dictionaries
Using disk-based dictionaries
DBM Example: Tracking Telephone Numbers
Advanced Disk-Based Dictionaries
gdbm
dbhash
Using BSD database objects
Accessing Relational Databases
Connection objects
Transactions
Cursor objects
Example: “Sounds-Like” Queries
Examining Relational Metadata
Example: Creating Auditing Tables
Advanced Features of the DB API
Input and output sizes
Reusable SQL statements
Database library information
Error hierarchy
Networking Background
Networking background
Working with Addresses and Host Names
Communicating with Low-Level Sockets
Creating and destroying sockets
Connecting sockets
Sending and receiving data
Using socket options
Converting numbers
Example: A Multicast Chat Application
Using SocketServers
The SocketServer family
Request handlers
Processing Web Browser Requests
BaseHTTPRequestHandler
SimpleHTTPRequestHandler
CGIHTTPRequestHandler
Example: form handler CGI script
Handling Multiple Requests Without Threads
asyncore
Python’s Internet Protocol Support
Python’s Internet protocol support
Retrieving Internet Resources
Treating a URL as a file
URLopeners
Extended URL opening
Sending HTTP Requests
Building and using request objects
Sending and Receiving E-Mail
Accessing POP3 accounts
Accessing SMTP accounts
Accessing IMAP accounts
Transferring Files via FTP
Retrieving Resources Using Gopher
Working with Newsgroups
Using the Telnet Protocol
Connecting
Reading and writing
Watching and waiting
Other methods
Writing CGI Scripts
Setting up CGI scripts
Accessing form fields
Advanced CGI functions
A note on debugging
A note on security
Manipulating URLs
Formatting Text
Formatter interface
Writer interface
Other module resources
Reading Web Spider Robot Files
Viewing Files in a Web Browser
Dissecting E-Mail Messages
Parsing a message
Retrieving header values
Other members
Address lists
rfc822 utility functions
MIME messages
Working with MIME Encoding
Encoding and decoding MIME messages
Parsing multipart MIME messages
Writing out multipart MIME messages
Handling document types
Encoding and Decoding Message Data
Uuencode
Base64
Quoted-printable
Working with UNIX Mailboxes
Working with MH mailboxes
Using Web Cookies
Cookies
Morsels
Example: a cookie importer
Markup Language Basics
Markup language basics
Tags are for metatext
Tag rules
Namespaces
Processing XML
Parsing HTML Files
HTMLParser methods
Handling tags
Other parsing methods
Handling unknown or bogus elements
Example: Bold Only
Example: Web Robot
Parsing XML with SAX
Using a ContentHandler
Example: blood-type extractor
Using parser (XMLReader) objects
SAX exceptions
Parsing XML with DOM
DOM nodes
Elements, attributes, and text
The document node (DOM)
Example: data import and export with DOM
Parsing XML with xmllib
Elements and attributes
XML handlers
Other XMLParser members
Getting Your Feet Wet
Creating a GUI
Building an interface with widgets
Widget options
Laying Out Widgets
Packer options
Grid options
Example: Breakfast Buttons
Using Common Options
Color options
Size options
Appearance options
Behavior options
Gathering User Input
Example: Printing Fancy Text
Using Text Widgets
Building Menus
Using Tkinter Dialogs
File dialogs
Example: Text Editor
Handling Colors and Fonts
Colors
Fonts
Drawing Graphics
The canvas widget
Manipulating canvas items
Using Timers
Example: A Bouncing Picture
Handling Events
Creating event handlers
Handling events
Binding mouse events
Binding keyboard events
Event objects
Example: A Drawing Canvas
Advanced Widgets
Listbox
Scale
Scrollbar
Example: Color Scheme Customizer
Creating Dialogs
Supporting Drag-and-Drop Operations
Using Cursors
Designing New Widgets
Further Tkinter Adventures
Additional widgets
Learning more
Introducing wxPython
Creating Simple wxPython Programs
Choosing Different Window Types
Managed windows
Nonmanaged windows
Using wxPython Controls
Common controls
Tree controls
Editor controls
Controlling Layout
Specifying coordinates
Sizers
Layout constraints
Layout algorithms
Using Built-in Dialogs
Drawing with Device Contexts
Adding Menus and Keyboard Shortcuts
Accessing Mouse and Keyboard Input
Other wxPython Features
Clipboard, drag and drop, and cursors
Graphics
Date and time
HTML
Printing
Other
A Curses Overview
A Curses overview
Starting Up and Shutting Down
Displaying and Erasing Text
Reading from the window (screen-scraping)
Erasing
Refreshing
Boxes and lines
The window background
Example: masking a box
Moving the Cursor
Getting User Input
Reading keys
Other keyboard-related functions
Fancy characters
Reading mouse input
Example: yes, no, or maybe
Managing Windows
Pads
Stacking windows
Editing Text
Using Color
Numbering
Setting colors
Tweaking the colors
Example: A Simple Maze Game
Beginning with the End in Mind
Beginning with the end in mind
Understanding the Lepto Language
Creating a Lepto Lexical Analyzer
The shlex module
Putting shlex to work
Adding Interactive-Mode Features
Using the cmd module
Subclassing cmd.Cmd
Executing Lepto Commands
Sound File Basics
Sound file basics
Playing Sounds
Playing sound on Windows
Playing and recording sound on SunOS
Examining Audio Files
Reading and Writing Audio Files
Reading and writing AIFF files with aifc
Reading and writing AU files with sunau
Reading and writing WAV files with wave
Example: Reversing an audio file
Reading IFF chunked data
Handling Raw Audio Data
Examining a fragment
Searching and matching
Translating between storage formats
Manipulating fragments
Image Basics
Image basics
Identifying Image File Types
Converting Between Color Systems
Color systems
Converting from one system to another
Handling Raw Image Data
Using the Python Imaging Library
Retrieving image information
Copying and converting images
Using PIL with Tkinter
Cropping and resizing images
Modifying pixel data
Other PIL features
Understanding Threads
Understanding threads
Spawning, Tracking, and Killing Threads
Creating threads with the thread module
Starting and stopping threads with the threading module
Thread status and information under threading
Finding threads under threading
Waiting for a thread to finish
Avoiding Concurrency Issues
Locking with thread
Locking with threading
Preventing Deadlock
Example: Downloading from Multiple URLs
Porting Threaded Code
Weaving Threads Together with Queues
Technical Note: How Simultaneous Is Simultaneous?
For More Information
Debugging Python Code
Starting and stopping the debugger
Debugging Python code
Examining the state of things
Setting breakpoints
Running
Aliases
Debugging tips
Working with docstrings
Automating Tests
Synching docstrings with code
Unit testing
Finding Bottlenecks
Profiling code
Using Profile objects
Calibrating the profiler
Customizing statistics
Common Optimization Tricks
Sorting
Threads
Taking out the Trash—the Garbage Collector
Reference counts and Python code
Reference counts and C/C++ code
Checking Passwords
Checking passwords
Running in a Restricted Environment
The rexec sandbox
Using a class fortress
Creating Message Fingerprints
Other uses
Using 1940s-Era Encryption
Extending and Embedding Overview
Extending and embedding overview
Writing a Simple Extension Module
Building and Linking
Converting Python Data to C
Unpacking normal arguments
Using special format characters
Unpacking keyword arguments
Unpacking zero arguments
Converting C Data to Python
Creating simple Python objects
Creating complex Python objects
Embedding the Interpreter
A simple example
Shutting down
Other setup functions
System information functions
Running Python Code from C
Using Extension Tools
SWIG
Extension classes
Tracking Reference Counts
Types of reference ownership
Tracking reference counts
Reference conventions
Common pitfalls
Using the Abstract and Concrete Object Layers
Object layers
Working with generic objects
Working with Number Objects
Any numerical type
Longs
Floating-point numbers
Complex numbers
Working with Sequence Objects
Any sequence type
Lists
Buffers
Unicode strings
Working with Mapping Objects
Functions for any mapping type
Using Other Object Types
Type
None
File
Module
CObjects
Creating Threads and Sub-Interpreters
Sub-interpreters
Index

Info and Rating

Category:

Uncategorized.

Rating:

Upload Date:

02/01/2012

Attribution Non-commercial

Tags:

No tags

ebook download or readfalse online.

Flag for inappropriate content

Python 2.1 Bible

Sections

Info and Rating

Download and print this document

Choose a format to download in

Choose a format to download in

Download and print this document

Choose a format to download in

Recommended

Recommended

Python 2.1 Bible

Sections

Info and Rating

Download and print this document

Choose a format to download in

Choose a format to download in

Download and print this document

Choose a format to download in

Recommended

Recommended

Other login options

Why Sign Up?

Login Successful

Sign Up Successful