book

Programming Python, 3rd Edition

Name: Programming Python, 3rd Edition
Author: Mark Lutz
ISBN: 9780596554613

by Mark Lutz

August 2006

Intermediate to advanced

1600 pages

51h 46m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Python ChangesExample ChangesTopic ChangesFocus Unchanged
It’s Been Updated for Python 2.4 (and 2.5)It’s Been ReorganizedIt Covers New TopicsIt’s Still Mostly Platform-NeutralC integration code platform issuesIt’s Still Focused for a More Advanced AudienceIt’s Still Example-Oriented
The Book Examples TreeThe Book Examples Distribution PackageRunning Examples: The Short StoryRunning Examples: The DetailsDemos and gadgetsSetup requirementsWeb-based examplesTop-level programs
1.4.1. Recent Growth (As of 2005, at Least)
2.3.1. Using Lists2.3.1.1. A database list2.3.1.2. Field labels2.3.2. Using Dictionaries2.3.2.1. Other ways to make dictionaries2.3.2.2. Lists of dictionaries2.3.2.3. Nested structures2.3.2.4. Dictionaries of dictionaries
2.4.1. Using Formatted Files2.4.1.1. Test data script2.4.1.2. Data format script2.4.1.3. Utility scripts2.4.2. Using Pickle Files2.4.3. Using Per-Record Pickle Files2.4.4. Using Shelves
2.5.1. Using Classes2.5.2. Adding Behavior2.5.3. Adding Inheritance2.5.4. Refactoring Code2.5.4.1. Augmenting methods2.5.4.2. Display format2.5.4.3. Constructor customization2.5.4.4. Alternative classes2.5.5. Adding Persistence2.5.6. Other Database Options
2.6.1. A Console Shelve Interface
2.7.1. GUI Basics2.7.2. Using OOP for GUIs2.7.3. Getting Input from a User2.7.4. A GUI Shelve Interface2.7.4.1. Coding the GUI2.7.4.2. Using the GUI2.7.4.3. Future directions
2.8.1. CGI Basics2.8.2. Running a Web Server2.8.3. Using Query Strings and urllib2.8.4. Formatting Reply Text2.8.5. A Web-Based Shelve Interface2.8.5.1. Coding the web site2.8.5.2. Using the web site2.8.5.3. Future directions
3.1.1. Why Python Here?3.1.2. The Next Five Chapters
3.2.1. Python System Modules3.2.2. Module Documentation Sources3.2.3. Paging Documentation Strings3.2.4. Introducing String Methods3.2.5. File Operation Basics3.2.6. Using Programs in Two Ways3.2.7. Python Library Manuals3.2.8. Commercially Published References
3.3.1. Platforms and Versions3.3.2. The Module Search Path3.3.3. The Loaded Modules Table3.3.4. Exception Details3.3.5. Other sys Module Exports
3.4.1. The Big os Lists3.4.2. Administrative Tools3.4.3. Portability Constants3.4.4. Basic os.path Tools3.4.5. Running Shell Commands from Scripts3.4.5.1. What’s a shell command?3.4.5.2. Running shell commands3.4.5.3. Communicating with shell commands3.4.5.4. Shell command limitations3.4.6. Other os Module Exports
3.6.1. CWD, Files, and Import Paths3.6.2. CWD and Command Lines
3.8.1. Fetching Shell Variables3.8.2. Changing Shell Variables3.8.3. Shell Variable Details
3.9.1. Redirecting Streams to Files and Programs3.9.1.1. Redirecting streams to files3.9.1.2. Chaining programs with pipes3.9.1.3. Coding alternatives3.9.1.4. Redirected streams and user interaction3.9.1.5. Reading keyboard input3.9.2. Redirecting Streams to Python Objects3.9.3. The StringIO Module3.9.4. Capturing the stderr Stream3.9.5. Redirection Syntax in Print Statements3.9.6. Other Redirection Options
4.2.1. Built-In File Objects4.2.1.1. Output files4.2.1.1.1. Opening4.2.1.1.2. Writing4.2.1.1.3. Closing4.2.1.2. Input files4.2.1.3. Reading lines with file iterators4.2.1.4. Other file object modes4.2.1.5. Binary datafiles4.2.1.6. End-of-line translations on Windows4.2.1.7. Parsing packed binary data with the struct module4.2.2. File Tools in the os Module4.2.2.1. Open mode flags4.2.2.2. Other os file tools4.2.3. File Scanners
4.3.1. Walking One Directory4.3.1.1. Running shell listing commands with os.popen4.3.1.2. The glob module4.3.1.3. The os.listdir call4.3.1.4. Splitting and joining listing results4.3.2. Walking Directory Trees4.3.2.1. The os.path.walk visitor4.3.2.2. The os.walk generator4.3.2.3. Recursive os.listdir traversals4.3.3. Rolling Your Own find Module
5.2.1. The fork/exec Combination5.2.1.1. os.exec call formats5.2.1.2. Spawned child program
5.3.1. The thread Module5.3.1.1. Synchronizing access to global objects5.3.1.2. Waiting for spawned thread exits5.3.2. The threading Module5.3.3. The Queue Module5.3.4. The Global Interpreter Lock and Threads5.3.4.1. The thread switch interval5.3.4.2. Atomic operations5.3.4.3. C API thread considerations
5.4.1. os Module Exits5.4.2. Exit Status Codes5.4.3. Process Exit Status5.4.4. Thread Exits
5.6.1. Anonymous Pipe Basics5.6.2. Bidirectional IPC with Pipes5.6.2.1. Deadlocks, flushes, and unbuffered streams5.6.3. Named Pipes (Fifos)
5.8.1. The os.spawn Calls5.8.2. Launching Programs on Windows5.8.2.1. Using the DOS start command5.8.2.2. Using start in Python scripts5.8.2.3. The os.startfile call5.8.3. Other Program Launch Options
6.2.1. Splitting Files Portably6.2.1.1. Operation modes6.2.1.2. Binary file access6.2.1.3. Manually closing files6.2.2. Joining Files Portably6.2.2.1. Reading by blocks or files6.2.2.2. Sorting filenames6.2.3. Usage Variations
6.3.1. Page Template File6.3.2. Page Generator Script
6.5.1. Packing Files “++”6.5.2. Application Hierarchy Superclasses6.5.2.1. StreamApp: adding stream redirection6.5.2.2. App: the root class6.5.2.3. Why use classes here?
6.6.1. Launcher Module Clients6.6.2. Launching Programs Without Environment Settings6.6.3. Launching Web Browsers Portably6.6.3.1. Launching browsers with command lines6.6.3.2. Launching browsers with function calls6.6.3.3. Viewing multimedia in browsers6.6.4. A Portable Media File Player Tool6.6.4.1. The Python webbrowser module6.6.4.2. The Python mimetypes module
7.2.1. Converting Line Ends in One File7.2.1.1. Slinging bytes and verifying results7.2.1.2. Nonintrusive conversions7.2.1.3. Slicing strings out of bounds7.2.1.4. Binary file mode revisited7.2.2. Converting Line Ends in One Directory7.2.3. Converting Line Ends in an Entire Tree7.2.3.1. The view from the top
7.3.1. Rewriting with os.path.walk
7.4.1. Greps and Globs in Shells and Python7.4.1.1. Cleaning up bytecode files7.4.2. A Python Tree Searcher
7.5.1. Editing Files in Directory Trees7.5.2. Global Replacements in Directory Trees7.5.3. Collecting Matched Files in Trees7.5.3.1. Suppressing status messages7.5.4. Recoding Fixers with Visitors7.5.5. Fixing File Permissions in Trees7.5.6. Changing Unix Executable Path Lines7.5.7. Summary: Counting Source Lines Four Ways
7.6.1. A Python Tree Copy Script7.6.2. Recoding Copies with a Visitor-Based Class
7.7.1. Recoding Deletions for Generality
7.8.1. Finding Directory Differences7.8.2. Finding Tree Differences7.8.3. Running the Script7.8.3.1. Verifying CD backups7.8.4. Reporting Differences
8.1.1. GUI Programming Topics
8.3.1. Tkinter Pragmatics8.3.2. Tkinter Documentation8.3.3. Tkinter Extensions8.3.4. Tkinter Structure
8.4.1. “Hello World” in Four Lines (or Less)
8.5.1. Making Widgets8.5.2. Geometry Managers8.5.3. Running GUI Programs8.5.3.1. Avoiding DOS consoles on Windows
8.6.1. Widget Resizing Basics8.6.2. Configuring Widget Options and Window Titles8.6.3. One More for Old Times’ Sake8.6.4. Packing Widgets Without Saving Them
8.7.1. Widget Resizing Revisited: Expansion
8.8.1. Lambda Callback Handlers8.8.1.1. Passing in values with default arguments8.8.1.2. Passing in values with enclosing scope references8.8.1.3. Enclosing scopes versus defaults8.8.2. Bound Method Callback Handlers8.8.3. Callable Class Object Callback Handlers8.8.4. Other Tkinter Callback Protocols8.8.5. Binding Events
8.9.1. Widget Resizing Revisited: Clipping8.9.2. Attaching Widgets to Frames8.9.3. Layout: Packing Order and Side Attachments8.9.4. The Packer’s Expand and Fill Revisited8.9.5. Using Anchor to Position Instead of Stretch
8.11.1. Attaching Class Components8.11.2. Extending Class Components8.11.3. Standalone Container Classes
9.1.1. This Chapter’s Topics
9.3.1. Toplevel and Tk Widgets9.3.2. Top-Level Window Protocols
9.4.1. Standard (Common) Dialogs9.4.1.1. A “smart” and reusable Quit button9.4.1.2. A dialog demo launcher bar9.4.1.3. Printing dialog results (and passing callback data with lambdas)9.4.1.4. Letting users select colors on the fly9.4.1.5. Other standard dialog calls9.4.2. The Old-Style Dialog Module9.4.3. Custom Dialogs9.4.3.1. Making custom dialogs modal9.4.3.2. Other ways to be modal
9.6.1. Message9.6.2. Entry9.6.2.1. Programming Entry widgets9.6.2.2. Laying out input forms9.6.2.3. Going modal again9.6.2.4. Tkinter “variables”
9.7.1. Checkbuttons9.7.1.1. Check buttons and variables9.7.2. Radio Buttons9.7.2.1. Radio buttons and variables9.7.2.2. Radio buttons without variables9.7.2.3. Hold onto your variables9.7.3. Scales (Sliders)9.7.3.1. Scales and variables
9.8.1. Attaching Frames9.8.2. Independent Windows9.8.3. Running Programs9.8.3.1. Cross-program communication9.8.3.2. Coding for reusability
9.9.1. Fun with Buttons and Pictures
9.10.1. PIL Basics9.10.2. Displaying Other Image Types with PIL9.10.2.1. Displaying all images in a directory9.10.3. Creating Image Thumbnails with PIL9.10.3.1. Performance: saving thumbnail files9.10.3.2. Layout: gridding and fixed-size widgets9.10.3.3. Scrolling and canvases
10.2.1. Top-Level Window Menus10.2.2. Frame- and Menubutton-Based Menus10.2.2.1. Using Menubuttons and Optionmenus10.2.3. Windows with Both Menus and Toolbars10.2.3.1. Automating menu construction
10.3.1. Programming Listboxes10.3.2. Programming Scroll Bars10.3.3. Packing Scroll Bars
10.4.1. Programming the Text Widget10.4.1.1. Text is a Python string10.4.1.2. String positions10.4.1.2.1. Text indexes10.4.1.2.2. Text marks10.4.1.2.3. Text tags10.4.2. Adding Text-Editing Operations10.4.2.1. Using the clipboard10.4.2.2. Composition versus inheritance10.4.2.3. It’s called “Simple” for a reason10.4.3. Advanced Text and Tag Operations
10.5.1. Basic Canvas Operations10.5.2. Programming the Canvas Widget10.5.2.1. Coordinates10.5.2.2. Object construction10.5.2.3. Object identifiers and operations10.5.2.4. Canvas object tags10.5.3. Scrolling Canvases10.5.4. Scrollable Canvases and Image Thumbnails10.5.4.1. Scrolling images too: PyPhoto (ahead)10.5.5. Using Canvas Events10.5.5.1. Binding events on specific items
10.6.1. Grid Basics10.6.2. grid Versus pack10.6.3. Combining grid and pack10.6.4. Making Gridded Widgets Expandable10.6.4.1. Resizing in grids10.6.4.2. Spanning columns and rows10.6.5. Laying Out Larger Tables with grid
10.7.1. Using Threads with GUIs10.7.2. Using the after Method10.7.2.1. Hiding and redrawing widgets and windows10.7.3. Simple Animation Techniques10.7.3.1. Using time.sleep loops10.7.3.2. Using widget.after events10.7.3.3. Using multiple time.sleep loop threads10.7.4. Other Animation Concepts: Threads and Toolkits
10.9.1. PyDemos Launcher Bar10.9.2. PyGadgets Launcher Bar
11.3.1. Subclass Protocols11.3.2. GuiMaker Classes11.3.3. GuiMaker Self-Test11.3.4. BigGui: A Client Demo Program
11.4.1. A Generic Shell-Tools Display11.4.2. Application-Specific Tool Set Classes11.4.3. Adding GUI Frontends to Command Lines
11.5.1. Using Redirection for the Packing Scripts
11.8.1. Placing Callbacks on Queues
11.9.1. Popping up GUI Windows on Demand11.9.2. Adding a GUI As a Separate Program: Sockets11.9.3. Adding a GUI As a Separate Program: Pipes
12.1.1. Examples in Other Chapters12.1.2. This Chapter’s Strategy
12.2.1. Running PyEdit12.2.1.1. Menus and toolbars12.2.1.2. Dialogs12.2.1.3. Running program code12.2.1.4. New features in version 2.012.2.2. PyEdit Source Code
12.3.1. Running PyPhoto12.3.2. PyPhoto Source Code
12.4.1. Running PyView12.4.2. PyView Source Code
12.5.1. Running PyDraw12.5.2. PyDraw Source Code
12.6.1. A Quick Geometry Lesson12.6.2. Running PyClock12.6.3. PyClock Source Code
12.7.1. Running PyToe12.7.2. PyToe Source Code (Book Examples Distribution)
13.1.1. Internet Scripting Topics13.1.1.1. What we will cover13.1.1.2. What we won’t cover13.1.1.3. Running examples in this part of the book
13.2.1. The Socket Layer13.2.1.1. Machine identifiers13.2.2. The Protocol Layer13.2.2.1. Port number rules13.2.2.2. Clients and servers13.2.2.3. Protocol structures13.2.3. Python’s Internet Library Modules
13.3.1. Socket Basics13.3.1.1. Server socket calls13.3.1.2. Client socket calls13.3.1.3. Running socket programs locally13.3.1.4. Running socket programs remotely13.3.1.5. Socket pragmatics13.3.1.6. Spawning clients in parallel13.3.1.7. Talking to reserved ports
13.4.1. Forking Servers13.4.1.1. Running the forking server13.4.1.2. Forking processes13.4.1.3. Exiting from children13.4.1.4. Killing the zombies13.4.1.5. Preventing zombies with signal handlers13.4.2. Threading Servers13.4.3. Standard Library Server Classes13.4.4. Third-Party Server Tools: Twisted13.4.5. Multiplexing Servers with select13.4.5.1. A select-based echo server13.4.5.2. Running the select server13.4.6. Choosing a Server Scheme
13.5.1. Running the File Server and Clients13.5.2. Adding a User-Interface Frontend13.5.2.1. Using Frames and command lines13.5.2.2. Using grids and function calls13.5.2.3. Using a reusable form-layout class
14.2.1. Fetching Files with ftplib14.2.2. Using urllib to FTP Files14.2.3. FTP get and put Utilities14.2.3.1. Download utility14.2.3.2. Upload utility14.2.3.3. Playing the Monty Python theme song14.2.3.4. Adding user interfaces14.2.4. Downloading Web Sites (Mirrors)14.2.5. Uploading Web Sites14.2.6. Refactoring Uploads and Downloads for Reuse14.2.6.1. Refactoring with functions14.2.6.2. Refactoring with classes14.2.7. Uploads and Deletes with Subdirectories14.2.7.1. Uploading local trees14.2.7.2. Deleting remote trees
14.4.1. Mail Configuration Module14.4.2. POP Mail Reader Script14.4.3. Fetching Messages14.4.4. Fetching Email at the Interactive Prompt
14.5.1. SMTP Mail Sender Script14.5.2. Sending Messages14.5.3. More Ways to Abuse the Net14.5.4. Back to the Big Internet Picture14.5.5. Sending Email from the Interactive Prompt
14.6.1. Message Objects14.6.2. Basic email Interfaces in Action
14.7.1. Running the pymail Console Client
14.8.1. Initialization File14.8.2. MailTool Class14.8.3. MailSender Class14.8.4. MailFetcher Class14.8.4.1. General usage14.8.4.2. Inbox synchronization tools14.8.5. MailParser Class14.8.6. Self-Test Script14.8.7. Updating the pymail Console Client
14.11.1. Other urllib Interfaces
15.1.1. Source Code Modules15.1.2. Why PyMailGUI?15.1.3. Running PyMailGUI15.1.4. Presentation Strategy15.1.5. New in This Edition
15.2.1. Getting Started15.2.2. Loading Mail15.2.3. Threading Model15.2.4. Load Server Interface15.2.5. Offline Processing with Save and Open15.2.6. Sending Email and Attachments15.2.7. Viewing Email and Attachments15.2.8. Email Replies and Forwards15.2.9. Deleting Email15.2.10. POP Message Numbers and Synchronization15.2.11. Multiple Windows and Status Messages
15.3.1. Code Reuse15.3.2. Code Structure15.3.3. PyMailGui2: The Main Module15.3.4. SharedNames: Program-Wide Globals15.3.5. ListWindows: Message List Windows15.3.6. ViewWindows: Message View Windows15.3.7. messagecache: Message Cache Manager15.3.8. popuputil: General-Purpose GUI Pop Ups15.3.9. wraplines: Line Split Tools15.3.10. mailconfig: User Configurations15.3.11. PyMailGuiHelp: User Help Text15.3.12. Ideas for Improvement
16.2.1. The Script Behind the Curtain16.2.2. Writing CGI Scripts in Python
16.3.1. Web Server Options16.3.2. Running a Local Web Server16.3.3. The Server-Side Examples Root Page16.3.4. Viewing Server-Side Examples and Output
16.4.1. A First Web Page16.4.1.1. HTML basics16.4.1.2. Internet addresses (URLs)16.4.1.3. Using minimal URLs16.4.1.4. HTML file permission constraints16.4.2. A First CGI Script16.4.2.1. Installing CGI scripts16.4.2.2. Finding Python on remote servers16.4.3. Adding Pictures and Generating Tables16.4.3.1. Table tags16.4.4. Adding User Interaction16.4.4.1. Submission page16.4.4.2. More on form tags16.4.4.3. Response script16.4.4.4. Passing parameters in URLs16.4.4.5. Testing outside browsers with the module urllib16.4.5. Using Tables to Lay Out Forms16.4.5.1. Converting strings in CGI scripts16.4.5.2. Debugging CGI scripts16.4.6. Adding Common Input Devices16.4.7. Changing Input Layouts16.4.7.1. Keeping display and logic separate16.4.8. Passing Parameters in Hardcoded URLs16.4.9. Passing Parameters in Hidden Form Fields
16.5.1. URL Query Parameters16.5.2. Hidden Form Input Fields16.5.3. HTTP “Cookies”16.5.3.1. Creating a cookie16.5.3.2. Receiving a cookie16.5.3.3. Using cookies in CGI scripts16.5.3.4. Handling cookies with the module urllib216.5.4. Server-Side Databases16.5.5. Extensions to the CGI Model16.5.6. Combining Techniques
16.6.1. Checking for Missing and Invalid Inputs
16.7.1. Step 1: Sharing Objects Between Pages—A New Input Form16.7.2. Step 2: A Reusable Form Mock-Up Utility16.7.3. Step 3: Putting It All Together—A New Reply Script
16.8.1. URL Escape Code Conventions16.8.2. Python HTML and URL Escape Tools16.8.3. Escaping HTML Code16.8.4. Escaping URLs16.8.5. Escaping URLs Embedded in HTML Code16.8.5.1. HTML and URL conflicts: &16.8.5.2. Avoiding conflicts
16.9.1. Displaying Arbitrary Server Files on the Client16.9.1.1. Handling private files and errors16.9.2. Uploading Client Files to the Server16.9.2.1. Handling client path formats16.9.3. More Than One Way to Push Bits over the Net
17.2.1. Implementation Overview17.2.2. New in This Edition17.2.3. Presentation Overview17.2.4. Running This Chapter’s Examples
17.3.1. Configuring PyMailCGI
17.4.1. The Message Composition Page17.4.2. The Send Mail Script17.4.3. Error Pages17.4.4. Common Look-and-Feel17.4.5. Using the Send Mail Script Outside a Browser
17.5.1. The POP Password Page17.5.2. The Mail Selection List Page17.5.3. Passing State Information in URL Link Parameters17.5.4. Security Protocols17.5.4.1. Reading mail with direct URLs17.5.5. The Message View Page17.5.6. Passing State Information in HTML Hidden Input Fields17.5.7. Escaping Mail Text and Passwords in HTML
17.6.1. Reply and Forward17.6.2. Delete17.6.3. Deletions and POP Message Numbers17.6.3.1. Inbox synchronization error potential17.6.3.2. Passing header text in hidden input fields (PyMailCGI_2.1)17.6.3.3. Server-side files for headers17.6.3.4. Delete on load
17.7.1. External Components and Configuration17.7.2. POP Mail Interface17.7.3. POP Password Encryption17.7.3.1. Manual data encryption: rotor (defunct)17.7.3.2. Manual data encryption: PyCrypto17.7.3.3. Secure HTTP transmissions17.7.3.4. Secure cookies17.7.3.5. The secret.py module17.7.3.6. Rolling your own encryptor17.7.4. Common Utilities Module
17.8.1. Other Approaches
18.2.1. Zope Overview18.2.1.1. Zope hierarchy model18.2.1.2. Zope scripting18.2.1.3. Zope components18.2.2. Zope Object Publishing18.2.3. A Zope External Method18.2.3.1. Calling through the Web18.2.3.2. Calling from other objects18.2.4. A Simple Zope Interactive Web Site
18.3.1. A Brief HTMLgen Tutorial
18.4.1. A Quick Introduction to Jython18.4.2. Why Jython?18.4.3. A Simple Jython Example18.4.4. Interface Automation Tricks18.4.5. Writing Java Applets in Jython18.4.6. Jython Trade-Offs18.4.7. Picking Your Python
18.5.1. A Simple Grail Applet Example
18.6.1. A Brief Introduction to XML Parsing
18.7.1. Active Scripting: Client-Side Embedding18.7.1.1. Active Scripting basics18.7.1.2. Embedding Python in HTML18.7.2. Active Server Pages: Server-Side Embedding18.7.2.1. A short ASP example18.7.3. The COM Connection18.7.3.1. A brief introduction to COM18.7.3.2. Python COM clients18.7.3.3. Python COM servers18.7.3.3.1. Using the Python server from a Python client18.7.3.3.2. Using the Python server from a Visual Basic client18.7.3.3.3. Using the Python server with client-side Active Scripting18.7.3.4. The bigger COM picture: DCOM
18.8.1. PSP in Webware and mod_python
18.9.1. Standard Library Socket Servers18.9.2. Standard Library Web Servers18.9.3. Third-Party Solutions
19.3.1. Using DBM Files
19.4.1. Using Object Pickling19.4.2. Picking in Action19.4.3. Pickler Protocols and cPickle
19.5.1. Using Shelves19.5.2. Storing Built-In Object Types in Shelves19.5.3. Storing Class Instances in Shelves19.5.4. Changing Classes of Objects Stored in Shelves19.5.5. Shelve Constraints19.5.5.1. Keys must be strings19.5.5.2. Objects are unique only within a key19.5.5.3. Updates must treat shelves as fetch-modify-store mappings19.5.5.4. Concurrent updates are not directly supported19.5.5.5. Underlying DBM format portability19.5.6. Pickled Class Constraints19.5.7. Other Shelve Limitations
19.6.1. A ZODB Tutorial19.6.1.1. Installing ZODB19.6.1.2. The ZEO distributed object server19.6.1.3. Creating a ZODB database19.6.1.4. Fetching and changing19.6.2. Using Classes with ZODB19.6.3. A ZODB People Database19.6.4. ZODB Resources
19.7.1. SQL Interface Overview19.7.2. An SQL Database API Tutorial19.7.2.1. The MySQL system19.7.2.2. Installation19.7.2.3. Getting started19.7.2.4. Making databases and tables19.7.2.5. Adding records19.7.2.6. Running queries19.7.2.7. Running updates19.7.3. Building Record Dictionaries19.7.3.1. Using table descriptions19.7.3.2. Record dictionaries19.7.3.3. Automating with scripts and modules19.7.4. Tying the Pieces Together19.7.5. Loading Database Tables from Files19.7.5.1. Loading with SQL and Python19.7.5.2. Python versus SQL19.7.6. SQL Utility Scripts19.7.6.1. Table load scripts19.7.6.2. Table display script19.7.6.3. Using the scripts19.7.7. SQL Resources
19.8.1. Processing Shelves with Code19.8.2. Adding a Graphical Interface19.8.3. PyForm GUI Implementation19.8.4. PyForm Table Wrappers19.8.5. PyForm Creation and View Utility Scripts19.8.5.1. Creating and browsing custom databases19.8.6. Data as Code19.8.7. Browsing Other Kinds of Objects with PyForm19.8.8. Browsing Other Kinds of Databases with PyForm19.8.9. PyForm Limitations
20.2.1. A Stack Module20.2.2. A Stack Class20.2.3. Customization: Performance Monitors20.2.4. Optimization: Tuple Tree Stacks20.2.5. Optimization: In-Place List Modifications20.2.6. Timing the Improvements20.2.6.1. Results under Python 1.5.220.2.6.2. Results under Python 2.4
20.3.1. Set Functions20.3.1.1. Supporting multiple operands20.3.2. Set Classes20.3.3. Optimization: Moving Sets to Dictionaries20.3.3.1. Timing the results under Python 2.420.3.3.2. Timing results under Python 1.5.2: version skew20.3.3.3. Using the Python profiler20.3.4. Optimizing fastset by Coding Techniques (or Not)20.3.5. Adding Relational Algebra to Sets (External)
20.6.1. Moving Graphs to Classes
20.9.1. Adding Comparison Functions
20.11.1. Running PyTree20.11.2. PyTree Source Code20.11.2.1. Tree-independent GUI implementation20.11.2.2. Tree wrappers and test widgets20.11.3. PyTree Does Parse Trees Too
21.3.1. Templating with Replacements and Formats21.3.2. Parsing with Splits and Joins21.3.3. Summing Columns in a File21.3.4. Parsing and Unparsing Rule Strings21.3.5. More on the holmes Expert System Shell
21.4.1. First Examples21.4.2. Using the re Module21.4.2.1. Module functions21.4.2.2. Compiled pattern objects21.4.2.3. Match objects21.4.2.4. Regular expression patterns21.4.3. Basic Patterns21.4.4. Scanning C Header Files for Patterns21.4.5. A File Pattern Search Utility
21.6.1. The Expression Grammar21.6.2. The Parser’s Code21.6.3. Adding a Parse Tree Interpreter21.6.4. Parse Tree Structure21.6.5. Exploring Parse Trees with PyTree21.6.6. Parsers Versus Python
21.7.1. A Simple Calculator GUI21.7.1.1. Building the GUI21.7.1.2. Running code strings21.7.1.3. Extending and attaching21.7.2. PyCalc—A Real Calculator GUI21.7.2.1. Running PyCalc21.7.2.2. Evaluating expressions with stacks21.7.2.3. PyCalc source code21.7.2.4. Using PyCalc as a component21.7.2.5. Adding new buttons in new components
22.2.1. Presentation Notes
22.5.1. Compilation and Linking22.5.1.1. Dynamic binding22.5.1.2. Static binding22.5.1.3. Static versus dynamic binding22.5.2. Compiling with the Distutils System22.5.3. Anatomy of a C Extension Module22.5.4. Data Conversions22.5.4.1. Python to C: using Python argument lists22.5.4.2. Python to C: using Python return values22.5.4.3. C to Python: returning values to Python22.5.4.4. Common conversion codes22.5.5. Error Handling22.5.5.1. Raising Python exceptions in C22.5.5.2. Detecting errors that occur in Python22.5.6. Reference Counts22.5.7. Other Extension Tasks: Threads
22.6.1. A Simple SWIG Example22.6.2. SWIG Details
22.7.1. Adding Wrapper Classes to Flat Libraries22.7.2. But Don’t Do That Either—SWIG
22.8.1. But Don’t Do That Either—SWIG
22.9.1. Anatomy of a C Extension Type22.9.2. Compiling and Running22.9.3. Timing the C Implementations22.9.4. Older Timing Results22.9.5. But Don’t Do That Either—SWIG
22.10.1. A Simple C++ Extension Class22.10.2. Wrapping the C++ Class with SWIG22.10.3. Using the C++ Class in Python22.10.3.1. Using the low-level extension module22.10.3.2. Subclassing the C++ class in Python22.10.3.3. Exploring the wrappers interactively
23.2.1. What Is Embedded Code?
23.3.1. Running Simple Code Strings23.3.1.1. Compiling and running23.3.2. Running Code Strings with Results and Namespaces23.3.3. Calling Python Objects23.3.4. Running Strings in Dictionaries23.3.5. Precompiling Strings to Bytecode
23.6.1. Running Objects with ppembed23.6.2. Running Code Strings with ppembed23.6.3. Running Customizable Validations23.6.3.1. Running function-based validations23.6.3.2. Other validation components23.6.4. ppembed Implementation23.6.5. Other Integration Examples (External)
23.7.1. Jython: Java Integration23.7.2. IronPython: C#/.NET Integration23.7.3. COM Integration on Windows23.7.4. CORBA Integration23.7.5. Other Languages23.7.6. Network-Based Integration Protocols23.7.7. Integration Versus Optimization23.7.7.1. Framework roles23.7.7.2. Extension module roles23.7.7.3. Picking an integration technology
24.4.1. The Static Language Build Cycle24.4.2. Artificial Complexities24.4.3. One Language Does Not Fit All
24.6.1. Python Provides Immediate Turnaround24.6.2. Python Is “Executable Pseudocode”24.6.3. Python Is OOP Done Right24.6.4. Python Fosters Hybrid Applications
24.10.1. Integration Isn’t Everything24.10.2. The End of the Java Wars24.10.3. We’re Not Off That Island Yet
24.11.1. Proof of Concept24.11.2. Integration Today24.11.3. Quality Counts

Overview

Already the industry standard for Python users, ProgrammingPython fromO'Reilly just got even better. This third edition has been updated toreflect current best practices andthe abundance of changes introduced by the latest version of thelanguage, Python 2.5.

Whether you're a novice or an advancedpractitioner, you'll find thisrefreshed book more than lives up to its reputation. ProgrammingPython, 3rd Edition, teaches you the rightway to code. It explains Python language syntax and programmingtechniques in a clear and concisemanner, with numerous examples that illustrate both correct usage andcommon idioms. By reading thiscomprehensive guide, you'll learn how to apply Python in real-worldproblem domains such as:

GUI programming
Internet scripting
Parallel processing
Database management
Networked applications

Programming Python, Third Edition coverseach of thesetarget domainsgradually, beginning with in-depth discussions of core concepts andthen progressing toward completeprograms. Large examples do appear, but only after you've learnedenough to understand their techniques andcode.

Along the way, you'll also learn how to use the Python language inrealistically scaled programs--concepts such as Object-Oriented Programming (OOP) and code reuseare recurring side themes throughout thistext. If you're interested in Python programming, then this O'Reillyclassic needs to be within arm's reach. Thewealth of practical advice, snippets of code, and patterns of programdesign can all be put into use on adaily basis--making your life easier and more productive.

Reviews of the second edition:

"...about as comprehensive as any book can be."
--Dr. Dobb's Journal

"If the language had manuals, they would undoubtedlybe the texts from O'Reilly...'Learning Python' and 'Programming Python'are definitive treatments."
--SD Times