Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

(backslash), The Module Search Path, The Hello World Selector
/ (forward slash), The Module Search Path
| (pipe character), Chaining programs with pipes
_ (underscore), Standalone Container Classes
* wildcard character, The glob module

A

after method
drawbacks, Using widget.after events
functionality, Using the after Method–Hiding and redrawing widgets and windows
scheduling functions, Time Tools, Threads, and Animation, Simple Animation Techniques
algebra, relational, Adding Relational Algebra to Sets (External)
anchoring widgets, Using Anchor to Position Instead of Stretch–Using Anchor to Position Instead of Stretch
animation
coordinate system and, Coordinates
graphics and, Graphics and gaming toolkits
other effects, Other animation effects
simple techniques, Simple Animation Techniques–Using multiple time.sleep loop threads
third-party toolkits, Graphics and gaming toolkits
threads and, Threads and animation
time.sleep loops, Using time.sleep loops–Using time.sleep loops, Using multiple time.sleep loop threads
anonymous pipes
basic functionality, Anonymous pipe basics–Anonymous pipe basics
bidirectional IPC and, Bidirectional IPC with anonymous pipes–Bidirectional IPC with anonymous pipes
defined, Interprocess Communication, Anonymous Pipes
output stream buffering, Output stream buffering revisited: Deadlocks and flushes–Output stream buffering revisited: Deadlocks and flushes
threads and, Anonymous pipes and threads
wrapping descriptors in file objects, Wrapping pipe descriptors in file objects
Apache web servers, Python Internet Development Options, Web Server Options
append list operator, A database list, Nested structures
arguments
global variables versus, Arguments versus globals, Arguments versus globals
pass-by-name, One More for Old Times’ Sake
threads and, Coding alternatives: busy loops, arguments, and context managers–Coding alternatives: busy loops, arguments, and context managers
Array object (multiprocessing), IPC Tools: Pipes, Shared Memory, and Queues
ASCII encoding, Unicode encodings for text files
askyesno function, Standard (Common) Dialogs
associated variables, tkinter “Variables” and Form Layout Alternatives–tkinter “Variables” and Form Layout Alternatives, Checkbuttons
asyncore.py module, Running the select server
attachments
propagating, Ideas for Improvement
sending via PyMailCGI, New in This Fourth Edition (Version 3.0)
sending via PyMailGUI, Sending Email and Attachments–Sending Email and Attachments
viewing via PyMailGUI, Viewing Email and Attachments
augmenting methods, Augmenting methods

B

backslash (), The Module Search Path, The Hello World Selector
backups, verifying, Verifying Backups
base64 module, Python’s Internet Library Modules
BASIC language, Enter Python
BDFL acronym, Other Database Options
BeautifulSoup third-party extension, mailconfig: User Configurations, Ideas for Improvement
Beazley, Dave, The SWIG Integration Code Generator
bell method, Using the after Method
BigGui client demo program, BigGui: A Client Demo Program–BigGui: A Client Demo Program
binary files
defined, The File Object Model in Python 3.X, Binary and Text Files
parsing with struct module, Parsing packed binary data with the struct module–Parsing packed binary data with the struct module
random access processing, Random access files–Random access files
Unicode encoding and, Other binary mode considerations
binary mode transfers, Uploading Site Directories
binary trees
built-in options, Built-in Options
defined, Binary Search Trees
implementing, Implementing Binary Trees–Trees with Both Keys and Values
binascii module, Python’s Internet Library Modules
bind method mechanism
binding events, Binding Events, Binding Events–More on <Destroy> events and the quit and destroy methods, Binding events on specific items–Binding events on specific items
binding tags, Advanced Text and Tag Operations
functionality, Other tkinter Callback Protocols
binding
events, Binding Events, Binding Events–More on <Destroy> events and the quit and destroy methods, Binding events on specific items–Binding events on specific items
reserved port servers, Binding reserved port servers
tags, Advanced Text and Tag Operations
binhex module, Python’s Internet Library Modules
BitmapImage widget class, The End of the Tutorial, Images–Fun with Buttons and Pictures
BooleanVar class, tkinter “Variables” and Form Layout Alternatives
Boost.Python system, Other Extending Tools
bound methods
callback handlers and, Bound Method Callback Handlers
defined, Using OOP for GUIs
PyMailGUI program support, Threading model implementation
recoding with, Recoding with classes and bound methods–Recoding with classes and bound methods
browsers
cookie support, Creating a cookie
displaying CGI context in, Debugging CGI scripts
Grail, Running Examples in This Part of the Book
PyMailCGI send mail script, Using the Send Mail Script Outside a Browser–Using the Send Mail Script Outside a Browser
testing with urllib.request, Testing outside browsers with the module urllib.request–Testing outside browsers with the module urllib.request
buffering
command pipes and, Buffering in other contexts: Command pipes revisited
line, Line buffering–Line buffering
output streams, Text-mode files and buffered output streams
Button widget class
command option, Checkbuttons
functionality, Adding Buttons and Callbacks–Adding Buttons and Callbacks, The End of the Tutorial
buttons
adding, Adding Buttons and Callbacks–Adding Buttons and Callbacks
adding in PyCalc, Adding new buttons in new components–Adding new buttons in new components
deferring calls, Deferring Calls with Lambdas and Object References
fixed-size, Layout options: Fixed-size buttons
Quit button, A “smart” and reusable Quit button
randomly changing images, Fun with Buttons and Pictures–Fun with Buttons and Pictures
bytearray string type, Other String Concepts in Python 3.X: Unicode and bytes
bytecode files
cleaning up, Cleaning Up Bytecode Files–Cleaning Up Bytecode Files
precompiling strings to, Precompiling Strings to Bytecode–Precompiling Strings to Bytecode
bytes string type, Other String Concepts in Python 3.X: Unicode and bytes, String types in the Text widget–String types in the Text widget, The problem with treating text as bytes–The problem with treating text as bytes

C

C language
API standard, C API thread considerations, The C Embedding API
classes and, Using Python Classes in C–Using Python Classes in C
embedding interface, Extending and Embedding–Extending and Embedding, The C Embedding API–Precompiling Strings to Bytecode
extending interface, Extending and Embedding–A Simple C Extension Module, Extending Python in C: Overview–A Simple C Extension Module
getenv function, Wrapping C Environment Calls
putenv function, Wrapping C Environment Calls, Wrapping C Environment Calls with SWIG
Python comparison, Enter Python
Python support, “I Am Lost at C”
scanning files for patterns, Scanning C Header Files for Patterns–Scanning C Header Files for Patterns
strop extension module, More on the holmes expert system shell
SWIG tool and, The SWIG Integration Code Generator–A Simple SWIG Example, Wrapping C Environment Calls with SWIG
wrapping environment calls, Wrapping C Environment Calls–Wrapping C Environment Calls with SWIG
C++ language, Wrapping C++ Classes with SWIG–Exploring the wrappers interactively, Other Extending Tools, Enter Python
CalcGui class, Running PyCalc, Evaluating expressions with stacks
calculators (see PyCalc program)
callable objects
defined, What Is Embedded Code?
overview, Calling Python Objects–Calling Python Objects
registering, Registering Callback Handler Objects–Registration Implementation
callback handlers
adding user-defined, Adding User-Defined Callback Handlers
additional protocols, Other tkinter Callback Protocols
binding events, Binding Events, Binding Events
bound method, Bound Method Callback Handlers
callable class object, Callable Class Object Callback Handlers
deferring calls, Deferring Calls with Lambdas and Object References–Deferring Calls with Lambdas and Object References
defined, Programming structure
lambda, Lambda Callback Handlers–But you must still sometimes use defaults instead of enclosing scopes
registering objects, Registering Callback Handler Objects–Registration Implementation
reloading dynamically, Reloading Callback Handlers Dynamically–Reloading Callback Handlers Dynamically
callbacks
adding, Adding Buttons and Callbacks–Adding Buttons and Callbacks
arguments versus globals, Arguments versus globals
passing data with lambdas, Printing dialog results and passing callback data with lambdas–Printing dialog results and passing callback data with lambdas
placing on queues, Placing Callbacks on Queues–Passing bound method callbacks on queues
Canvas widget class
addtag_withtag method, Canvas object tags
basic operations, Basic Canvas Operations
controlling image displays, Scrolling and canvases (ahead)
coordinate system, Coordinates
create_ method, Object identifiers and operations
create_polygon method, Object construction
delete method, Using Canvas Events
event support, Using Canvas Events–Binding events on specific items
find_closest method, Canvas object tags, Binding events on specific items
freeform graphic support, Future directions
functionality, The End of the Tutorial, Images, Text, Canvas
image thumbnails, Scrollable Canvases and Image Thumbnails–Scrolling images too: PyPhoto (ahead)
itemconfig method, Object identifiers and operations
move method, Canvas object tags
object construction, Object construction
object identifiers, Object identifiers and operations
object tags, Canvas object tags
postscript method, Canvas object tags
programming, Programming the Canvas Widget–Canvas object tags
scrolling canvases, Scrolling Canvases–Scrolling Canvases
tag_bind method, Binding events on specific items
tkraise method, Object identifiers and operations
update method, Simple Animation Techniques
xscrollcommand option, Programming Scroll Bars
xview method, Programming Scroll Bars
yscrollcommand option, Programming Scroll Bars
yview method, Programming Scroll Bars
canvases
basic operations, Basic Canvas Operations–Basic Canvas Operations
clearing, Using Canvas Events
coordinate system, Coordinates
defined, Canvas
dragging out object shapes, Using Canvas Events
event support, Using Canvas Events–Binding events on specific items
image thumbnails, Scrollable Canvases and Image Thumbnails–Scrolling images too: PyPhoto (ahead)
moving objects, Using Canvas Events
object construction, Object construction
object identifiers, Object identifiers and operations
object tags, Canvas object tags
scrolling, Scrolling Canvases–Scrolling Canvases
cat command, Shell command limitations
cd command, CWD and Command Lines
cenviron module, Wrapping C Environment Calls
cgi module
escape function, Formatting Reply Text, The Hello World Selector, More on HTML and URL Escapes–Escaping URLs Embedded in HTML Code, Passing State Information in URL Link Parameters, Escaping Mail Text and Passwords in HTML
FieldStorage class, Response script, Adding Common Input Devices, The Hello World Selector, Passing State Information in URL Link Parameters
functionality, Python’s Internet Library Modules, Writing CGI Scripts in Python
PyMailCGI program and, Implementation Overview
CGI scripts, “Oh, What a Tangled Web We Weave”
(see also PyMailCGI program; server-side scripting/processing)
adding common input devices, Adding Common Input Devices–Adding Common Input Devices
adding pictures, Adding Pictures and Generating Tables–Table tags
adding user interaction, Adding User Interaction–Testing outside browsers with the module urllib.request
building first web page, A First Web Page–HTML file permission constraints
changing input layouts, Changing Input Layouts–Keeping display and logic separate
checking inputs, Checking for Missing and Invalid Inputs–Checking for Missing and Invalid Inputs
converting strings, Converting strings in CGI scripts
debugging, Debugging CGI scripts–Debugging CGI scripts
defined, The Script Behind the Curtain
escape conventions, More on HTML and URL Escapes–Avoiding conflicts
examples, A First CGI Script–Finding Python on remote servers
formatting reply text, Formatting Reply Text
functionality, CGI Basics–GUIs versus the Web, Python Internet Development Options, What’s a Server-Side CGI Script?–The Script Behind the Curtain
functions and, Passing parameters in URLs
generating tables, Adding Pictures and Generating Tables–Table tags
Hello World program, The Hello World Selector–Checking for Missing and Invalid Inputs
installing, Installing CGI scripts–Installing CGI scripts
laying out forms with tables, Using Tables to Lay Out Forms–Debugging CGI scripts
model extensions, Extensions to the CGI Model
name conventions, Installing CGI scripts
passing parameters in hidden form fields, Passing Parameters in Hidden Form Fields
passing parameters in URLs, Passing Parameters in Hardcoded URLs–Passing Parameters in Hardcoded URLs
permissions, Handling private files and errors
programming suggestions, Future directions
query strings, Using Query Strings and urllib–Using Query Strings and urllib
refactoring code, Refactoring Code for Maintainability–Step 3: Putting It All Together—A New Reply Script
running, Running Server-Side Examples–Viewing Server-Side Examples and Output
saving state information in, Saving State Information in CGI Scripts–Combining Techniques
text decoding issues, Parser decoding requirement
urllib module and, Using Query Strings and urllib–Using Query Strings and urllib
using cookies in, Using cookies in CGI scripts
web servers and, Running a Web Server–Running a Web Server
writing, Writing CGI Scripts in Python–Writing CGI Scripts in Python
Checkbutton widget class
command option, Checkbuttons
functionality, The End of the Tutorial, Checkbuttons–Check buttons and variables
variables and, Check buttons and variables–Check buttons and variables
child process
defined, Forking Processes
exiting from, Exiting from children
spawning, Spawned child program
chmod command, Script start-up pointers, CGI Basics, HTML file permission constraints
class instances
persistence and, Persistence Options in Python
pickling, Pickling in Action
storing in shelves, Storing Class Instances in Shelves–Storing Class Instances in Shelves
class object callback handlers, Callable Class Object Callback Handlers
classes
adding behavior, Adding Behavior
adding inheritance, Adding Inheritance
adding persistence, Adding Persistence–Adding Persistence
alternative, Alternative classes
C language and, Using Python Classes in C–Using Python Classes in C
changing for objects, Changing Classes of Objects Stored in Shelves
container, Standalone Container Classes–Standalone Container Classes
customizing widgets with, Customizing Widgets with Classes–Common appearance
moving graphs to, Moving Graphs to Classes–Moving Graphs to Classes
programming considerations, Using Classes–Using Classes
recoding with, Recoding with classes and bound methods–Recoding with classes and bound methods
refactoring scripts with, Refactoring with classes–Refactoring with classes
reusable GUI components, Reusable GUI Components with Classes–Standalone Container Classes
sets and, Set Classes–Set Classes
stacks and, A Stack Class–A Stack Class
client-side scripting/processing
accessing newsgroups, NNTP: Accessing Newsgroups–NNTP: Accessing Newsgroups
accessing websites, HTTP: Accessing Websites–HTTP: Accessing Websites
additional options, Other Client-Side Scripting Options
client socket calls, Client socket calls
console-based email client, A Console-Based Email Client–Running the pymail Console Client
development options, Python Internet Development Options
fetching email via POP, POP: Fetching Email–Fetching Email at the Interactive Prompt
handling multiple clients, Handling Multiple Clients–Summary: Choosing a Server Scheme
Internet applications and, Other Approaches
mailtools utility package, The mailtools Utility Package–Running the pymail2 console client
parsing/composing mail content, email: Parsing and Composing Mail Content–Summary: Solutions and workarounds
processing Internet email, Processing Internet Email–Unicode in Python 3.X and Email Tools
protocol considerations, Clients and servers
PyMailGUI program and, “Use the Source, Luke”
Python support, “Socket to Me!”
sending email via SMTP, SMTP: Sending Email–Sending Email at the Interactive Prompt
spawning clients in parallel, Spawning Clients in Parallel–Preview: Denied client connections
transferring directories with ftplib, Transferring Directories with ftplib–Refactoring with classes
transferring directory trees, Transferring Directory Trees with ftplib–Downloading Remote Trees
transferring files over the Internet, FTP: Transferring Files over the Net
transferring files with ftplib, Transferring Files with ftplib–Adding a User Interface
urllib module, The urllib Package Revisited–Invoking programs and escaping text
client/server architecture
defined, Clients and servers
transferring files, Transferring Files to Clients and Servers–More Than One Way to Push Bits over the Net
clipboard interface, Using the clipboard
clipping widgets, Widget Resizing Revisited: Clipping
closing files, Closing, Ensuring file closure: Exception handlers and context managers–Input files
cloud computing, Python Internet Development Options
code files, What Is Embedded Code?
code strings
defined, What Is Embedded Code?
precompiling, Precompiling Strings to Bytecode–Precompiling Strings to Bytecode
running in dictionaries, Running Strings in Dictionaries
running simple, Running Simple Code Strings–Compiling and running
running with results/namespaces, Running Code Strings with Results and Namespaces–Running Code Strings with Results and Namespaces
colors, selecting on the fly, Letting users select colors on the fly
columns in files, summing, Summing Columns in a File–Summing with dictionaries
COM (Component Object Model), Python Internet Development Options, Other Integration Topics
command-line arguments
accessing, “I’d Like to Have an Argument, Please”
parsing, Parsing Command-Line Arguments
sys module and, Command-Line Arguments–Parsing Command-Line Arguments
command-line pipes
buffering and, Output stream buffering revisited: Deadlocks and flushes, Buffering in other contexts: Command pipes revisited
GUI programs and, Adding a GUI As a Separate Program: Command Pipes–Other uses for threaded pipe GUIs
sockets and, Sockets versus command pipes
command-line tools, ShellGui: GUIs for Command-Line Tools–Room for improvement
common dialogs, Standard (Common) Dialogs–Other standard dialog calls
comparedirs function, Finding Directory Differences
comparing directory trees, Comparing Directory Trees–Reporting Differences and Other Ideas
connection objects (FTP)
cwd method, Uploading Local Trees
defined, IPC Tools: Pipes, Shared Memory, and Queues
mkd method, Uploading Local Trees
retrbinary method, Transferring Files with ftplib, Download utility, Downloading Site Directories
retrlines method, Download utility, Downloading Site Directories
storbinary method, Upload utility
storlines method, Upload utility
console window
avoiding DOS consoles, Avoiding DOS consoles on Windows
shelve interface, A Console Shelve Interface–A Console Shelve Interface
console-based email client (see pymail console client)
constructors, customizing, Constructor customization
container classes, Standalone Container Classes–Standalone Container Classes
context managers
file closure and, Ensuring file closure: Exception handlers and context managers–Ensuring file closure: Exception handlers and context managers
file filters and, File filters
threads and, Coding alternatives: busy loops, arguments, and context managers–Coding alternatives: busy loops, arguments, and context managers
converting strings, String Method Basics, Converting strings in CGI scripts
cookies
creating, Creating a cookie
defined, HTTP “Cookies”
handling with urllib.request, Handling cookies with the urllib.request module
receiving, Receiving a cookie
security considerations, Secure cookies
using in CGI scripts, Using cookies in CGI scripts
coordinate system, canvas, Coordinates
copying directory trees, Copying Directory Trees–Copying Directory Trees
CORBA
integration considerations, Other Integration Topics
ORB support, Python Internet Development Options
persistence options, Persistence Options in Python
counting source code lines, Counting Source Code Lines (Visitor)
cregister module, Registration Implementation
csh shell language, Redirecting input and output with subprocess
ctypes module
binary data and, Using a reusable form-layout class
functionality, Other Extending Tools
integration considerations, Extending and Embedding
shared memory and, IPC Tools: Pipes, Shared Memory, and Queues
current working directory
accessing, “I’d Like to Have an Argument, Please”
command lines and, CWD and Command Lines
defined, Current Working Directory
import paths and, CWD, Files, and Import Paths
CXX system, Other Extending Tools
Cygwin system
C extension module, A Simple C Extension Module
C++ extension class, A Simple C++ Extension Class
forking processes, Forking Processes, Spawned child program, Running the forking server
running code strings, Compiling and running
Cython system, Extending and Embedding, Other Extending Tools

D

Dabo builder, Python GUI Development Options
data structures
binary trees, Binary Search Trees–Trees with Both Keys and Values
graph searching, Graph Searching–Moving Graphs to Classes
implementing sets, Implementing Sets–Adding Relational Algebra to Sets (External)
implementing stacks, Implementing Stacks–More on performance analysis
permuting sequences, Permuting Sequences–Permuting Sequences
reversing/sorting sequences, Reversing and Sorting Sequences–Data Structures Versus Built-ins: The Conclusion
subclassing built-in types, Subclassing Built-in Types–Subclassing Built-in Types
databases, SQL Database Interfaces
(see also SQL databases)
additional information, Other Database Options
creating with SQLite, Making databases and tables
displaying with pprint module, Dictionaries of dictionaries
freely available interfaces, SQL Database Interfaces
server-side, Server-Side Databases
db.keys method, Dictionaries of dictionaries
DBM files
defined, Persistence Options in Python, DBM Files
shelve constraints and, Underlying DBM format portability
standard operations, Using DBM Files
Unicode and, Using Shelves
usage considerations, Using DBM Files–DBM Details: Files, Portability, and Close
dbm module, Using DBM Files, DBM Details: Files, Portability, and Close, Shelve Files
DCOM (Distributed Component Object Model), Python Internet Development Options
deadlocks, output stream buffering and, Output stream buffering revisited: Deadlocks and flushes–Output stream buffering revisited: Deadlocks and flushes
debugging CGI scripts, Debugging CGI scripts–Debugging CGI scripts
delete statement (SQL), Running updates
deleting remote trees, Deleting Remote Trees–Deleting Remote Trees
dialog module, The Old-Style Dialog Module
dialogs
custom, Custom Dialogs–Other ways to be modal
flavors of, Dialogs
generating on demand, A dialog demo launcher bar–A dialog demo launcher bar
printing results, Printing dialog results and passing callback data with lambdas–Printing dialog results and passing callback data with lambdas
PyEdit text editor, Dialogs, Font dialog, Modal dialog state fix, New Grep dialog: Threaded and Unicode-aware file tree search
reusable Quit button, A “smart” and reusable Quit button
selecting colors on the fly, Letting users select colors on the fly
standard/common, Standard (Common) Dialogs–Other standard dialog calls
dialogTable module, A dialog demo launcher bar, Printing dialog results and passing callback data with lambdas
dictionaries
building, Building Record Dictionaries–Automating with scripts and modules
of dictionaries, Dictionaries of dictionaries–Dictionaries of dictionaries
implementing graph searching, Implementing Graph Search
lists of, Lists of dictionaries
making, Other ways to make dictionaries
moving sets to, Optimization: Moving Sets to Dictionaries–Timing the results under Python 3.1
nested structures, Nested structures
record examples, Using Dictionaries
running code strings in, Running Strings in Dictionaries
summing with, Summing with dictionaries
dictionary iterators, Dictionaries of dictionaries
dir command
filename patterns, Running shell listing commands with os.popen
functionality, Module Documentation Sources
usage example, What’s a shell command?
dirdiff tool, Finding Tree Differences–Finding Tree Differences
directories
displaying images in, Displaying all images in a directory
finding differences, Finding Directory Differences–Finding Directory Differences
name conventions, Installing CGI scripts
reporting differences in, Reporting Differences and Other Ideas–Reporting Differences and Other Ideas
scanning, Scanning the Standard Library Directory
transferring with ftplib, Transferring Directories with ftplib–Refactoring with classes
walking, Walking One Directory–Splitting and joining listing results, Visitor: Walking Directories “++”–Other Visitor Examples (External)
web-based interfaces and, Directories, string formatting, and security–Directories, string formatting, and security
directory paths
backslashes and, The Module Search Path
scanning, Scanning the Module Search Path–Scanning the Module Search Path
scripts and, CWD, Files, and Import Paths
splitting/joining listing results, Splitting and joining listing results
directory tools
handling Unicode filenames, Handling Unicode Filenames in 3.X: listdir, walk, glob–Unicode policies: File content versus file names
overview, Directory Tools
walking directory trees, Walking Directory Trees–Recursive os.listdir traversals
walking one directory, Walking One Directory–Splitting and joining listing results
directory trees
cleaning up bytecode files, Cleaning Up Bytecode Files–Cleaning Up Bytecode Files
comparing, Comparing Directory Trees–Reporting Differences and Other Ideas
copying, Copying Directory Trees–Copying Directory Trees
editing files in, Editing Files in Directory Trees (Visitor)–Editing Files in Directory Trees (Visitor)
finding differences, Finding Tree Differences–Finding Tree Differences
global replacements in, Global Replacements in Directory Trees (Visitor)–Global Replacements in Directory Trees (Visitor)
PyEdit text editor, New Grep dialog: Threaded and Unicode-aware file tree search
scanning, The os.walk visitor–The os.walk visitor, Scanning the Standard Library Tree
searching, Searching Directory Trees–A Python Tree Searcher
transferring with ftplib, Transferring Directory Trees with ftplib–Downloading Remote Trees
walking, Walking Directory Trees–Recursive os.listdir traversals
disutils package, A Simple C Extension Module
Django framework, Python Internet Development Options, Keeping display and logic separate
__doc__ attribute
formatting display, Paging Documentation Strings
functionality, Module Documentation Sources
doctest framework, Running the Test Driver
documentation sources
modules, Module Documentation Sources
recent release manuals, The C Embedding API
XML parsing, Other XML topics
DOM parsers, XML and HTML Parsing, DOM parsing
DOS console, avoiding, Avoiding DOS consoles on Windows
DoubleVar class, tkinter “Variables” and Form Layout Alternatives
downloading files (see transferring files)
Drake, Fred L., Jr., Other XML topics
Durus system, The ZODB Object-Oriented Database

E

Earley algorithm, Advanced Language Tools
EBCDIC encoding, Unicode encodings for text files
editing files in directory trees, Editing Files in Directory Trees (Visitor)–Editing Files in Directory Trees (Visitor)
EditVisitor class, Editing Files in Directory Trees (Visitor)
EIBTI acronym, The End of the Demo
ElementTree package, XML and HTML Parsing
ElementTree parsing, XML and HTML Parsing, ElementTree parsing
email
console-based client, A Console-Based Email Client–Running the pymail Console Client
deleting, Deleting Email–Deleting Email
fetching at interactive prompt, Fetching Email at the Interactive Prompt
fetching via POP, POP: Fetching Email–Fetching Email at the Interactive Prompt
handling HTML content, New in Version 3.0 (Fourth Edition), Handling HTML Content in Email
inbox synchronization errors, Inbox synchronization error potential
Internationalization and, New in Version 3.0 (Fourth Edition), Mail Content Internationalization Support–Mail Content Internationalization Support
loading, Loading Mail
mailtools utility package, The mailtools Utility Package–Running the pymail2 console client
parsing/composing mail content, email: Parsing and Composing Mail Content–Summary: Solutions and workarounds
processing over Internet, Processing Internet Email–Unicode in Python 3.X and Email Tools
reading with direct URLs, Reading mail with direct URLs
recipient options, Email Replies and Forwards and Recipient Options–Email Replies and Forwards and Recipient Options
replies and forwards, Email Replies and Forwards and Recipient Options–Email Replies and Forwards and Recipient Options
sending at interactive prompt, Sending Email at the Interactive Prompt
sending attachments, Sending Email and Attachments–Sending Email and Attachments, New in This Fourth Edition (Version 3.0)
sending by SMTP, SMTP: Sending Email–Sending Email at the Interactive Prompt, Sending Mail by SMTP–Using the Send Mail Script Outside a Browser
Unicode encoding and, Unicode in Python 3.X and Email Tools
viewing attachments, Viewing Email and Attachments–Viewing Email and Attachments, New in the Prior Edition (Version 2.0)
email addresses, Message address header encodings and parsing, and header creation–Message address header encodings and parsing, and header creation
email module package
basic interfaces, Basic email Package Interfaces in Action–Handling multipart messages
functionality, Python’s Internet Library Modules, Unicode in Python 3.X and Email Tools, email: Parsing and Composing Mail Content
Internationalized headers, Message header encodings: email package support
limitations overview, Unicode, Internationalization, and the Python 3.1 email Package
message address headers, Message address header encodings and parsing, and header creation–Message address header encodings and parsing, and header creation
message composition issues, Workaround: Message composition for non-ASCII text parts is broken–Workaround: Message composition for non-ASCII text parts is broken
Message objects, Message Objects–Message Objects
message text generation issues, Workaround: Message text generation for binary attachment payloads is broken–Workaround: Message text generation for binary attachment payloads is broken
parser decoding requirement, Parser decoding requirement–Parser decoding requirement
PyMailCGI program and, Implementation Overview, The Message View Page
PyMailGUI program and, Viewing Email and Attachments, Email Replies and Forwards and Recipient Options, Ideas for Improvement
text payload encodings, Text payload encodings: Handling mixed type results–Text payload encodings: Using header information to decode
embedding integration mode
basic techniques, Basic Embedding Techniques–Precompiling Strings to Bytecode
C embedding API, The C Embedding API–What Is Embedded Code?
defined, Extending and Embedding
registering callback handler objects, Registering Callback Handler Objects–Registration Implementation
enclosing scope reference mode, Passing in enclosing scope values with default arguments–But you must still sometimes use defaults instead of enclosing scopes
encryption, password, POP Password Encryption–Rolling your own encryptor
end-of-line character ( )
CGI scripts, Installing CGI scripts
overview, A Custom Paging Script
in text files, End-of-line translations for text files–End-of-line translations for text files
Text widget and, Text is a Python string
endian-ness, Parsing packed binary data with the struct module
Entry widget class
associated variables and, tkinter “Variables” and Form Layout Alternatives–tkinter “Variables” and Form Layout Alternatives
functionality, The End of the Tutorial, Entry–Programming Entry widgets
laying out input forms, Laying Out Input Forms–Going modal again
programming widgets, Programming Entry widgets
xscrollcommand option, Programming Scroll Bars
xview method, Programming Scroll Bars
yscrollcommand option, Programming Scroll Bars
yview method, Programming Scroll Bars
environment variables (see shell variables)
eval function
C API equivalent, The C Embedding API
converting strings, Converting strings in CGI scripts
parsing support, Advanced Language Tools
PyCalc support, Building the GUI, Running code strings
Evaluator class, Evaluating expressions with stacks
event handlers (see callback handlers)
events
binding, Binding Events, Binding Events–More on <Destroy> events and the quit and destroy methods, Binding events on specific items–Binding events on specific items
Canvas widget support, Using Canvas Events–Binding events on specific items
mouse-related, Binding Events–More on <Destroy> events and the quit and destroy methods
routing, Registration Implementation
triggering, Registration Implementation
exception handlers, file closure and, Ensuring file closure: Exception handlers and context managers–Ensuring file closure: Exception handlers and context managers
exec function
C API equivalent, The C Embedding API
converting strings, Converting strings in CGI scripts
parsing support, Advanced Language Tools
PyCalc support, Building the GUI, Running code strings
exit status
forking processes and, Process Exit Status and Shared State
shell command codes, Shell Command Exit Status Codes–Exit status with subprocess
threads and, Thread Exits and Shared State–Thread Exits and Shared State
Expat parser, XML and HTML Parsing
extend list operator, A database list
extending integration mode
additional tools, Other Extending Tools–Other Extending Tools
defined, Extending and Embedding
overview, Extending Python in C: Overview
simple C module, A Simple C Extension Module
simple C++ class, A Simple C++ Extension Class–A Simple C++ Extension Class
SWIG tool, The SWIG Integration Code Generator–A Simple SWIG Example

F

f2py system, Other Extending Tools
FastCGI extension, Extensions to the CGI Model
FFI (foreign function interface), Other Extending Tools
field labels (lists), Field labels–Field labels
FieldStorage class, Response script, Adding Common Input Devices, The Hello World Selector, Passing State Information in URL Link Parameters
fifos (see named pipes)
file descriptors
defined, Anonymous pipe basics
wrapping in file objects, Wrapping descriptors in file objects, Wrapping pipe descriptors in file objects
file download system, A Simple Python File Server–Using a reusable form-layout class
file objects
alternate open options, Other open options
built-in, Using Built-in File Objects–Other open options
close method, Output files, Closing
defined, File Tools
ensuring closure, Ensuring file closure: Exception handlers and context managers–Ensuring file closure: Exception handlers and context managers
file object model, The File Object Model in Python 3.X
input files, Input files–Input files
output files, Output files–Closing
read method, Input files
readline method, Input files, Reading lines with file iterators
readlines method, Input files, Input files, Reading lines with file iterators, Summing Columns in a File
seek method, Random access files
wrapping descriptors in, Wrapping descriptors in file objects, Wrapping pipe descriptors in file objects
write method, Output files
writelines method, Writing
file scanners, File Scanners–File filters
file tools
binary files, The File Object Model in Python 3.X, Binary and Text Files–Random access files
built-in file objects, Using Built-in File Objects–Other open options
file object model, The File Object Model in Python 3.X
file scanners, File Scanners–File filters
os module support, Lower-Level File Tools in the os Module
overview, File Tools
text files, The File Object Model in Python 3.X, Binary and Text Files–Random access files
File Transfer Protocol (see FTP)
files, Test data script
(see also formatted files)
closing, Closing, Ensuring file closure: Exception handlers and context managers–Input files
code files, What Is Embedded Code?
current working directory and, CWD, Files, and Import Paths
editing in directory trees, Editing Files in Directory Trees (Visitor)–Editing Files in Directory Trees (Visitor)
joining, Joining Files Portably–Joining Files Portably, Usage Variations–Usage Variations
loading database tables, Loading Database Tables from Files–Python versus SQL
name conventions, File name conventions, Installing CGI scripts
opening, Opening, Other open options
persistence options, Persistence Options in Python
private, Handling private files and errors–Handling private files and errors
redirecting streams to, Redirecting Streams to Files and Programs–Coding alternatives for adders and sorters
sockets looking like, Making Sockets Look Like Files and Streams–Sockets versus command pipes
splitting, Splitting Files Portably–Splitting Files Portably, Usage Variations–Usage Variations
summing columns in, Summing Columns in a File–Summing with dictionaries
system scripting and, File Operation Basics
transferring over the Internet, FTP: Transferring Files over the Net, Using urllib to Download Files–Using urllib to Download Files
transferring to clients/servers, Transferring Files to Clients and Servers–More Than One Way to Push Bits over the Net
transferring with ftplib, Transferring Files with ftplib–Adding a User Interface
Unicode text in, Unicode text in files
writing, Writing
FileVisitor class, Visitor: Walking Directories “++”–Visitor: Walking Directories “++”
filters
file scanning and, File filters
spam, Ideas for Improvement
find module, Rolling Your Own find Module–The fnmatch module
find shell command, Greps and Globs and Finds
flash method, Using the after Method
Flex framework, Python GUI Development Options
FLI format, Graphics and gaming toolkits
flushes
deadlocks and, Output stream buffering revisited: Deadlocks and flushes
output stream buffering and, Output stream buffering revisited: Deadlocks and flushes–Output stream buffering revisited: Deadlocks and flushes
fnmatch module, The glob module, The fnmatch module–The fnmatch module
font input dialog, Font dialog
foreign function interface (FFI), Other Extending Tools
forking processes
fork/exec combination, The fork/exec Combination–Spawned child program
functionality, “Telling the Monkeys What to Do”, Forking Processes–Forking Processes
obtaining exit status, Process Exit Status and Shared State
obtaining shared state, Process Exit Status and Shared State
os.exec call formats, os.exec call formats
server considerations, Forking Servers–Why multiprocessing doesn’t help with socket server portability
spawned child program, Spawned child program
formatted files
data format script, Data format script–Data format script
test data script, Test data script
utility scripts, Utility scripts
forms
action option, More on form tags
changing input layouts, Changing Input Layouts–Keeping display and logic separate
HTML tags, Submission page–More on form tags
input, Laying Out Input Forms–Going modal again, Grid Basics: Input Forms Revisited
input fields, More on form tags
laying out with tables, Using Tables to Lay Out Forms–Debugging CGI scripts
method option, More on form tags
mocking up inputs, The Hello World Selector
passing parameters in hidden fields, Passing Parameters in Hidden Form Fields, Hidden Form Input Fields
reusable form mock-up utility, Step 2: A Reusable Form Mock-Up Utility–Step 2: A Reusable Form Mock-Up Utility
sharing objects between pages, Step 1: Sharing Objects Between Pages—A New Input Form–Step 1: Sharing Objects Between Pages—A New Input Form
FORTRAN language, Other Extending Tools
forward slash (/), The Module Search Path
Frame widget class
adding multiple widgets, Adding Multiple Widgets
attaching widgets to frames, Attaching Widgets to Frames
functionality, The End of the Tutorial
GUI considerations, Using OOP for GUIs, Reusable GUI Components with Classes
menus, Frame- and Menubutton-Based Menus–Using Menubuttons and Optionmenus
frozen binaries, Future directions, Ideas for Improvement
FTP (File Transfer Protocol)
functionality, FTP: Transferring Files over the Net
get and put utilities, FTP get and put Utilities–Playing the Monty Python theme song
timeout errors, Uploading Site Directories
FTP objects
cwd method, Uploading Local Trees
delete method, Uploading Site Directories
mkd methods, Uploading Local Trees
nlst method, Downloading Site Directories, Uploading Site Directories
ftplib module
adding user interface, Adding a User Interface–Adding a User Interface
functionality, Python’s Internet Library Modules, Python’s Internet Library Modules
transferring directories, Transferring Directories with ftplib–Refactoring with classes
transferring directory trees, Transferring Directory Trees with ftplib–Downloading Remote Trees
transferring files, Transferring Files with ftplib–Adding a User Interface
functions
CGI scripts and, Passing parameters in URLs
refactoring scripts with, Refactoring with functions–Refactoring with functions
sets and, Set Functions–Supporting multiple operands
threads and, Threads

G

gaming toolkits, Graphics and gaming toolkits
gcc command, A Simple C Extension Module
generator functions, The os.walk visitor
geometry managers
grid, Going modal again, Layout options: Gridding, Grids–Laying Out Larger Tables with grid, Comparing grid and pack–Spanning columns and rows, Using grids and function calls
packer, Geometry Managers, Widget Resizing Basics, Layout: Packing Order and Side Attachments–Using Anchor to Position Instead of Stretch, Comparing grid and pack–Laying Out Larger Tables with grid
getaddresses utility, Message address header encodings and parsing, and header creation
getfile module
FTP-based, FTP: Transferring Files over the Net, Download utility
server-side examples, Viewing Server-Side Examples and Output, Handling private files and errors, Uploading Client Files to the Server, More Than One Way to Push Bits over the Net
socket-based, A Simple Python File Server–A Simple Python File Server
getopt module, Parsing Command-Line Arguments
getpass.getpass method, Transferring Files with ftplib
GIL (global interpreter lock)
atomic operations, Atomic operations
C API thread considerations, C API thread considerations
functionality, More on the Global Interpreter Lock–More on the Global Interpreter Lock
multiprocessing and, A process-based alternative: multiprocessing (ahead)
thread switch interval, The thread switch interval
threads and, Threads
Gilligan factor, The “Gilligan Factor”
glob module
button images, Fun with Buttons and Pictures
functionality, Using Per-Record Pickle Files, Python System Modules, The glob module
glob function, The glob module, Handling Unicode Filenames in 3.X: listdir, walk, glob
scanning directories, Scanning the Standard Library Directory
searching directory trees, Greps and Globs and Finds
global interpreter lock (see GIL)
global variables
arguments versus, Arguments versus globals, Arguments versus globals
multiprocessing module and, Shared memory and globals–Shared memory and globals
Google App Engine, Python Internet Development Options
Grail browser, Running Examples in This Part of the Book
graph searching
defined, Graph Searching
implementing, Implementing Graph Search–Implementing Graph Search
moving graphs to classes, Moving Graphs to Classes–Moving Graphs to Classes
graphical user interface (see GUI)
grep command, Greps and Globs and Finds, New Grep dialog: Threaded and Unicode-aware file tree search–Grep Unicode model
grid geometry manager
combining with packer, Combining grid and pack–Combining grid and pack
file download system, Using grids and function calls
functionality, Going modal again, Layout options: Gridding, Grids
input forms, Grid Basics: Input Forms Revisited
laying out larger tables, Laying Out Larger Tables with grid–Laying Out Larger Tables with grid
making expandable, Making Gridded Widgets Expandable
packer comparison, Comparing grid and pack–Comparing grid and pack
reasons for using, Why Grids?
resizing in grids, Resizing in grids
spanning rows/columns, Spanning columns and rows
GUI (graphical user interface), GUI Programming Topics
(see also tkinter module)
adding buttons, Adding Buttons and Callbacks–Widget Resizing Revisited: Expansion
adding callback handlers, Adding User-Defined Callback Handlers–Binding Events
adding callbacks, Adding Buttons and Callbacks–Widget Resizing Revisited: Expansion
adding multiple widgets, Adding Multiple Widgets–Using Anchor to Position Instead of Stretch
adding to non-GUI code, More Ways to Add GUIs to Non-GUI Code–Other uses for threaded pipe GUIs
additional information, Where to Go from Here
attaching frames, Attaching Frames–Configuring at construction time
basic functionality, GUI Basics–GUI Basics
building for PyCalc, Building the GUI
coding techniques, Coding the GUI, “Hello World” in Four Lines (or Less), GUIs, Threads, and Queues–GUIs, Threads, and Queues
for command-line tools, ShellGui: GUIs for Command-Line Tools–Room for improvement
customizing, Using OOP for GUIs
customizing widgets with classes, Customizing Widgets with Classes–Common appearance
development options, Python GUI Development Options–Python GUI Development Options
geometry managers, Geometry Managers
Hello World program, “Hello World” in Four Lines (or Less), One More for Old Times’ Sake
independent windows, Independent Windows–Independent Windows
inputting user data, Getting Input from a User
making widgets, Making Widgets
OOP considerations, Using OOP for GUIs–Using OOP for GUIs
programming suggestions, Future directions–Future directions, GUI Programming Topics
reloading callback handlers, Reloading Callback Handlers Dynamically–Reloading Callback Handlers Dynamically
reusable components, Reusable GUI Components with Classes–Standalone Container Classes
running programs, Running the Examples, Running GUI Programs, Running Programs–Coding for reusability
shelve interface, A GUI Shelve Interface–Future directions
threads and, Preview: GUIs and Threads–Preview: GUIs and Threads, Using Threads with tkinter GUIs–Using Threads with tkinter GUIs, Thread exits in GUIs, Updating GUIs within threads…and other nonsolutions
toolkit suggestions, Future directions
GuiMaker tool
BigGui client demo program, BigGui: A Client Demo Program–BigGui: A Client Demo Program
classes supported, GuiMaker Classes
functionality, GuiMaker: Automating Menus and Toolbars–GuiMaker: Automating Menus and Toolbars
self-test, GuiMaker Self-Test
subclass protocols, Subclass Protocols
GuiMixin tool
functionality, Automating menu construction, GuiMixin: Common Tool Mixin Classes
mixin utility classes, Mixin Utility Classes–Mixin Utility Classes
PyCalc program, Running PyCalc
widget builder functions, Widget Builder Functions
GuiStreams tool
functionality, GuiStreams: Redirecting Streams to Widgets–GuiStreams: Redirecting Streams to Widgets
redirecting packing scripts, Using Redirection for the Packing Scripts

H

hashing technique, Using DBM Files
Hello World program, “Hello World” in Four Lines (or Less), One More for Old Times’ Sake, The Hello World Selector–Checking for Missing and Invalid Inputs
help function, Paging Documentation Strings
hidden fields
passing header text in, Alternative: Passing header text in hidden input fields (PyMailCGI_2.1)–Alternative: Passing header text in hidden input fields (PyMailCGI_2.1)
passing parameters in, Passing Parameters in Hidden Form Fields, Hidden Form Input Fields
passing state information in, Passing State Information in HTML Hidden Input Fields
HList widget, Ideas for Improvement
holmes expert system shell
functionality, More on the holmes expert system shell
rule strings, Parsing and Unparsing Rule Strings
HTML
basic overview, HTML basics
building web pages with, A First Web Page
CGI script escape conventions, More on HTML and URL Escapes–Avoiding conflicts
escaping mail text/passwords, Escaping Mail Text and Passwords in HTML–Escaping Mail Text and Passwords in HTML
file permission constraints, HTML file permission constraints
form tags, Submission page–More on form tags
hidden input fields, Passing State Information in HTML Hidden Input Fields
Internet applications and, Other Approaches
parsing support, Python Internet Development Options, XML and HTML Parsing, HTML Parsing in Action–Extracting plain text from HTML (revisited)
PyMailGUI text extraction, New in Version 3.0 (Fourth Edition), Handling HTML Content in Email
table tags, Table tags
URL conflicts and, HTML and URL conflicts: &
html.entities module, Handling HTML entity references (revisited)
html.parser module
fetched data considerations, HTTP: Accessing Websites
functionality, Python’s Internet Library Modules, XML and HTML Parsing, HTML Parsing in Action–Extracting plain text from HTML (revisited)
screen scraping support, Python Internet Development Options
HTMLgen tool, Python Internet Development Options
HTTP
accessing websites, HTTP: Accessing Websites–HTTP: Accessing Websites
cookie support, HTTP “Cookies”–Handling cookies with the urllib.request module
http.client module, Python’s Internet Library Modules, HTTP: Accessing Websites
http.cookiejar module, Python’s Internet Library Modules, HTTP “Cookies”, Handling cookies with the urllib.request module
http.cookies module, Python’s Internet Library Modules, HTTP “Cookies”
http.server module, Python’s Internet Library Modules, HTTP: Accessing Websites
HTTPS (secure HTTP), HTTPS: Secure HTTP transmissions
HTTP_COOKIE environment variable, Receiving a cookie
hyperlinks, Ideas for Improvement, HTML basics, Passing Parameters in Hardcoded URLs–Passing Parameters in Hardcoded URLs

I

IANA (Internet Assigned Numbers Authority), Python’s Internet Library Modules
Icon language, Enter Python
IDLE interface
functionality, tkinter Extensions
running GUI programs, Running GUI Programs
text editor positioning issues, Update for initial positioning
IETF (Internet Engineering Task Force), Python’s Internet Library Modules
images
adding with CGI scripts, Adding Pictures and Generating Tables–Table tags
displaying, Images–Fun with Buttons and Pictures
processing with PIL, Viewing and Processing Images with PIL–Scrolling and canvases (ahead)
scrolling, Scrolling images too: PyPhoto (ahead)
thumbnails, Creating Image Thumbnails with PIL–Scrolling and canvases (ahead), Scrollable Canvases and Image Thumbnails–Scrolling images too: PyPhoto (ahead)
in toolbars, Using images in toolbars, too–Using images in toolbars, too
ImageTk module, Scrollable Canvases and Image Thumbnails
imaplib module, Python’s Internet Library Modules, Processing Internet Email
__import__ function, Importing by name string
independent programs
sockets and, Sockets and independent programs
starting, Starting Independent Programs
independent windows, Independent Windows–Independent Windows
indexes, Text indexes
inheritance
classes and, Adding Inheritance
SimpleEditor class and, Composition versus inheritance
Input class, Redirecting Streams to Python Objects
input files, Input files–Input files, Unicode file and display model
input forms
grid basics, Grid Basics: Input Forms Revisited
laying out, Laying Out Input Forms–Going modal again
input function, Standard Streams
input/output streams
capturing stderr stream, Capturing the stderr Stream
CGI scripts and, Writing CGI Scripts in Python
io.BytesIO class, The io.StringIO and io.BytesIO Utility Classes
io.StringIO class, The io.StringIO and io.BytesIO Utility Classes
output stream buffering, Output stream buffering: A first look, Output stream buffering revisited: Deadlocks and flushes–Output stream buffering revisited: Deadlocks and flushes
PyMailCGI program and, Common Utilities Module
redirecting print calls, Redirection Syntax in Print Calls
redirecting to files/programs, Redirecting Streams to Files and Programs–Coding alternatives for adders and sorters
redirecting to Python objects, Redirecting Streams to Python Objects–Redirecting Streams to Python Objects
redirecting to widgets, GuiStreams: Redirecting Streams to Widgets–Using Redirection for the Packing Scripts
redirecting with os.popen, Other Redirection Options: os.popen and subprocess Revisited, Redirecting input or output with os.popen
redirecting with subprocess, Other Redirection Options: os.popen and subprocess Revisited, Redirecting input and output with subprocess–Redirecting input and output with subprocess
redirection utility, A Stream Redirection Utility–Sockets versus command pipes
sockets looking like, Making Sockets Look Like Files and Streams–Sockets versus command pipes
standard streams, “I’d Like to Have an Argument, Please”, Standard Streams
user interaction and, Redirected Streams and User Interaction–Redirected Streams and User Interaction
insert command (SQL), Adding records
Inter-Process Communication (see IPC)
interact function, Redirecting Streams to Files and Programs
Internationalization
i18n message headers, Message header encodings: email package support–Message header encodings: email package support, New in This Fourth Edition (Version 3.0)
mail content support, New in Version 3.0 (Fourth Edition), Mail Content Internationalization Support–Mail Content Internationalization Support
Internet Assigned Numbers Authority (IANA), Python’s Internet Library Modules
Internet Engineering Task Force (IETF), Python’s Internet Library Modules
Internet Service Providers (ISPs), Generating Redirection Web Pages, Transferring Directories with ftplib, POP: Fetching Email
Internet-related scripting
development options, Python Internet Development Options–Python Internet Development Options
handling multiple clients, Handling Multiple Clients–Summary: Choosing a Server Scheme
library modules and, Python’s Internet Library Modules–Python’s Internet Library Modules
protocols and, The Protocol Layer–Protocol structures
Python file server, A Simple Python File Server–Using a reusable form-layout class
sockets and, The Socket Layer–Machine identifiers, Socket Programming–Binding reserved port servers
sockets like files/streams, Making Sockets Look Like Files and Streams–Sockets versus command pipes
IntVar class, tkinter “Variables” and Form Layout Alternatives
io.BytesIO class, The io.StringIO and io.BytesIO Utility Classes
io.StringIO class, The io.StringIO and io.BytesIO Utility Classes
IPC (Inter-Process Communication)
anonymous pipes, Interprocess Communication, Anonymous Pipes–Output stream buffering revisited: Deadlocks and flushes
bidirectional, Bidirectional IPC with anonymous pipes–Bidirectional IPC with anonymous pipes
FastCGI and, Extensions to the CGI Model
multiprocessing module and, Interprocess Communication, IPC Tools: Pipes, Shared Memory, and Queues–Queues and subclassing
named pipes, Interprocess Communication, Named Pipes (Fifos)–Named pipe use cases
overview, Interprocess Communication
shared memory, Interprocess Communication
signals, Interprocess Communication, Signals–Signals
sockets, Python System Modules, Interprocess Communication, Sockets: A First Look–Socket use cases, The Socket Layer
IronPython
development options, Python Internet Development Options
integration considerations, Extending and Embedding, Other Integration Topics
overview, Python GUI Development Options, Other Extending Tools
ISPs (Internet Service Providers), Generating Redirection Web Pages, Transferring Directories with ftplib, POP: Fetching Email
iterators, line, Other os Module Exports, Reading lines with file iterators–Reading lines with file iterators, File filters

J

Java language, Enter Python
JavaFX platform, Python GUI Development Options
joining files, Joining Files Portably–Joining Files Portably, Usage Variations–Usage Variations
Jones, Christopher A., Other XML topics
Jython
development options, Python Internet Development Options
integration considerations, Extending and Embedding, Other Integration Topics
overview, Python GUI Development Options, Other Client-Side Scripting Options, Other Extending Tools

K

Kennedy, Bill, “Oh, What a Tangled Web We Weave”
kill shell command, Signals, Preventing zombies with signal handlers on Linux
kwParsing system, Advanced Language Tools

L

Label widget class
functionality, The End of the Tutorial
pack method, Packing Widgets Without Saving Them
LabelFrame widget class, Other Widgets and Options
labels
bg option, Configuring Widget Appearance
customizing, Configuring Widget Appearance
expand option, Configuring Widget Appearance
fg option, Configuring Widget Appearance
fill option, Configuring Widget Appearance
font attribute, Configuring Widget Appearance
height attribute, Configuring Widget Appearance
pack option, Configuring Widget Appearance
width attribute, Configuring Widget Appearance
LALR parsers, Advanced Language Tools
lambda callback handlers
callback scope issues, Callback Scope Issues–But you must still sometimes use defaults instead of enclosing scopes
deferring calls, Deferring Calls with Lambdas and Object References–Deferring Calls with Lambdas and Object References
functionality, Lambda Callback Handlers
LAMP acronym, Other themes in this part of the book
language analysis (see text processing and language analysis)
languages2common module, Step 1: Sharing Objects Between Pages—A New Input Form
languages2reply module, Step 3: Putting It All Together—A New Reply Script–Step 3: Putting It All Together—A New Reply Script
launchmodes module, A Portable Program-Launch Framework, Running Programs
lexical analysis (see text processing and language analysis)
library modules, Python’s Internet Library Modules–Python’s Internet Library Modules
line buffering, Line buffering–Line buffering
Lisp language, Enter Python
LIST command (FTP), Downloading Site Directories
list comprehensions, summing with, Summing with zips and comprehensions
list operators
append, A database list, Nested structures
extend, A database list
functionality, Using Lists
Listbox widget class
curselection method, Programming Listboxes
functionality, The End of the Tutorial, Listboxes and Scrollbars
insert method, Programming Listboxes
programming, Programming Listboxes–Programming Listboxes
runCommand method, Programming Listboxes
xscrollcommand option, Programming Scroll Bars
xview method, Programming Scroll Bars
yscrollcommand option, Programming Scroll Bars
yview method, Programming Scroll Bars
lists
database lists, A database list
of dictionaries, Lists of dictionaries
field labels, Field labels–Field labels
in-place modifications, Optimization: In-Place List Modifications–Optimization: In-Place List Modifications
sample records, Using Lists
stacks as, Built-in Options
loops
threads and, Coding alternatives: busy loops, arguments, and context managers–Coding alternatives: busy loops, arguments, and context managers
time.sleep, Simple Animation Techniques, Using time.sleep loops–Using time.sleep loops, Using multiple time.sleep loop threads
ls command
filename patterns, Running shell listing commands with os.popen
shell command limitations, Shell command limitations

M

M2Crypto third-party package, HTTPS: Secure HTTP transmissions
Mac environment
language support, Other Extending Tools
programming user interfaces, Python GUI Development Options, Python GUI Development Options
tkinter support, Running the Examples
machine names, Machine identifiers
mail configuration module, Mail Configuration Module–POP Mail Reader Script, Implementation Overview, Using the Send Mail Script Outside a Browser
mail reader tool, POP: Fetching Email, POP Mail Reader Script–Fetching Messages
mail sender script, SMTP Mail Sender Script–Sending Email at the Interactive Prompt
mailbox module, Python’s Internet Library Modules
MailFetcher class, MailFetcher Class–MailParser Class
MailParser class, MailParser Class
MailSender class, MailSender Class–MailFetcher Class
MailTool class, MailTool Class
mailtools utility package
initialization file, Initialization File
MailFetcher class, MailFetcher Class–MailParser Class
MailParser class, MailParser Class
MailSender class, MailSender Class–MailFetcher Class
MailTool class, MailTool Class
overview, The mailtools Utility Package
pymail client and, Updating the pymail Console Client–Running the pymail2 console client
PyMailCGI and, Implementation Overview, The Mail Selection List Page, The Message View Page, POP Mail Interface
PyMailGUI and, Sending Email and Attachments, POP Message Numbers and Synchronization
selftest.py module, The mailtools Utility Package, Self-Test Script–Updating the pymail Console Client
mainloop function (tkinter), tkinter Coding Basics, tkinter Coding Alternatives
marks, text, Text marks
match objects (re module), First Examples
media files, playing, Playing Media Files–Running the Script
Menu widget class
add_cascade method, Top-Level Window Menus
functionality, The End of the Tutorial, Top-Level Window Menus–Top-Level Window Menus
Menubutton widget class, The End of the Tutorial, Frame- and Menubutton-Based Menus–Using Menubuttons and Optionmenus
menus
automating, Automating menu construction, GuiMaker: Automating Menus and Toolbars–BigGui: A Client Demo Program
defined, Menus
displaying in windows, Windows with Both Menus and Toolbars–Windows with Both Menus and Toolbars
frame-based, Frame- and Menubutton-Based Menus–Using Menubuttons and Optionmenus
menubutton-based, Frame- and Menubutton-Based Menus–Using Menubuttons and Optionmenus
PyEdit text editor, Menus and toolbars
top-level, Top-Level Window Menus–Top-Level Window Menus
message headers
email addresses, Message address header encodings and parsing, and header creation–Message address header encodings and parsing, and header creation
Internationalized, Message header encodings: email package support
mailtools utility package, Unicode issues for attachments, save files, and headers, Unicode decoding for text part payloads and message headers
passing text in hidden fields, Alternative: Passing header text in hidden input fields (PyMailCGI_2.1)–Alternative: Passing header text in hidden input fields (PyMailCGI_2.1)
Message objects
composing messages, Basic email Package Interfaces in Action–Handling multipart messages
functionality, Message Objects–Message Objects
get_content_charset method, Text payload encodings: Using header information to decode
get_payload method, Text payload encodings: Handling mixed type results
multipart messages, Handling multipart messages
Message Passing Interface (MPI) standard, “Telling the Monkeys What to Do”
Message widget class, The End of the Tutorial, Message
messagebox module, Standard (Common) Dialogs
MFC (Microsoft Foundation Classes), Python GUI Development Options
mimetypes module
functionality, The Python mimetypes Module–Using mimetypes guesses for SearchVisitor, Python’s Internet Library Modules
guess_extension method, Message Objects
guess_type method, Message Objects
playing media files, Playing Media Files–Playing Media Files
selecting transfer modes, Downloading Site Directories, Uploading Site Directories
minimal URLs, Using minimal URLs, Step 1: Sharing Objects Between Pages—A New Input Form
mixin utility classes, Mixin Utility Classes–Mixin Utility Classes
mmap module, Interprocess Communication
model-view-controller (MVC) structure, Python Internet Development Options
module documentation sources, Module Documentation Sources
mod_python module, Python Internet Development Options, Web Server Options, Extensions to the CGI Model
Monty Python theme song, Playing the Monty Python theme song
more function
chaining with pipes, Chaining programs with pipes
functionality, A Custom Paging Script
mouse-related events, Binding Events–More on <Destroy> events and the quit and destroy methods
MPEG format, Graphics and gaming toolkits
MPI (Message Passing Interface) standard, “Telling the Monkeys What to Do”
multiplexing servers, Multiplexing Servers with select–Summary: Choosing a Server Scheme
multiprocessing (see parallel processing)
multiprocessing module
additional tools supported, And Much More–And a little less…
constraints, And a little less…
functionality, Python System Modules, The multiprocessing Module–Why multiprocessing?
GIL and, A process-based alternative: multiprocessing (ahead)
implementation, Implementation and usage rules
IPC support, Interprocess Communication, IPC Tools: Pipes, Shared Memory, and Queues–Queues and subclassing
launching GUIs as programs, Launching GUIs as programs other ways: multiprocessing–Launching GUIs as programs other ways: multiprocessing
processes and locks, The Basics: Processes and Locks–Implementation and usage rules
socket server portability and, Why multiprocessing doesn’t help with socket server portability–Why multiprocessing doesn’t help with socket server portability
starting independent programs, Starting Independent Programs
usage rules, Implementation and usage rules
Musciano, Chuck, “Oh, What a Tangled Web We Weave”
MVC (model-view-controller) structure, Python Internet Development Options
mysql-python interface, Persistence Options in Python

N

name conventions
CGI scripts, Installing CGI scripts
files, File name conventions
__name__ variable, Using Programs in Two Ways
named pipes
basic functionality, Named pipe basics–Named pipe basics
creating, Named Pipes (Fifos)
defined, Interprocess Communication, Anonymous Pipes
use cases, Named pipe use cases
namespaces
creating, Running Strings in Dictionaries
running code strings with, Running Code Strings with Results and Namespaces–Running Code Strings with Results and Namespaces
natural language processing, Advanced Language Tools
nested structures
dictionaries, Nested structures
pickling, Pickled Objects, Pickling in Action
uploading local trees, Uploading Local Trees–Uploading Local Trees
Network News Transfer Protocol (NNTP), NNTP: Accessing Newsgroups–NNTP: Accessing Newsgroups, More Than One Way to Push Bits over the Net
network scripting
development options, Python Internet Development Options–Python Internet Development Options
handling multiple clients, Handling Multiple Clients–Summary: Choosing a Server Scheme
library modules and, Python’s Internet Library Modules–Python’s Internet Library Modules
making sockets look like files/streams, Making Sockets Look Like Files and Streams–Sockets versus command pipes
protocols and, The Protocol Layer–Protocol structures
Python file server, A Simple Python File Server–Using a reusable form-layout class
sockets and, The Socket Layer–Machine identifiers, Socket Programming–Binding reserved port servers
newsgroups
accessing, NNTP: Accessing Newsgroups–NNTP: Accessing Newsgroups
handling messages, Ideas for Improvement
NLTK suite, Advanced Language Tools
NNTP (Network News Transfer Protocol), NNTP: Accessing Newsgroups–NNTP: Accessing Newsgroups, More Than One Way to Push Bits over the Net
nntplib module, Python’s Internet Library Modules, NNTP: Accessing Newsgroups–NNTP: Accessing Newsgroups
numeric tools, A Quick Geometry Lesson
NumPy programming extension, A Quick Geometry Lesson, Extending and Embedding

O

object references
callback handlers as, Reloading Callback Handlers Dynamically
deferring calls, Deferring Calls with Lambdas and Object References–Deferring Calls with Lambdas and Object References
object relational mappers (see ORMs)
Object Request Broker (ORB), Python Internet Development Options
object types, storing in shelves, Storing Built-in Object Types in Shelves
object-oriented databases (OODBs), Persistence Options in Python
object-oriented programming (see OOP)
objects
callable, What Is Embedded Code?, Calling Python Objects–Calling Python Objects, Registering Callback Handler Objects–Registration Implementation
changing classes, Changing Classes of Objects Stored in Shelves
converting to strings, Pickled Objects
pickled, Persistence Options in Python, Pickled Objects–Pickle Details: Protocols, Binary Modes, and _pickle
sharing between pages, Step 1: Sharing Objects Between Pages—A New Input Form–Step 1: Sharing Objects Between Pages—A New Input Form
shelve constraints, Objects are unique only within a key
offline processing, PyMailGUI program, Offline Processing with Save and Open–Offline Processing with Save and Open
onSignal handler function, Signals
OODBs (object-oriented databases), Persistence Options in Python
OOP (object-oriented programming)
adding behavior, Adding Behavior
adding inheritance, Adding Inheritance
adding persistence, Adding Persistence–Adding Persistence
alternative database options, Other Database Options
class considerations, Using Classes–Using Classes
GUI considerations, Using OOP for GUIs–Using OOP for GUIs
programming considerations, Step 3: Stepping Up to OOP–Step 3: Stepping Up to OOP, Python Is OOP Done Right
refactoring code, Refactoring Code–Alternative classes
open function
buffering policy, Other open options
functionality, File Tools, Using Built-in File Objects
modes supported, Other open options
open source software, This Chapter’s Strategy, Python’s Internet Library Modules
opening files, Opening, Other open options
optimization
in-place list modifications, Optimization: In-Place List Modifications–Optimization: In-Place List Modifications
moving sets to dictionaries, Optimization: Moving Sets to Dictionaries–Timing the results under Python 3.1
tuple tree stacks, Optimization: Tuple Tree Stacks–Optimization: Tuple Tree Stacks
Optionmenu widget class, Using Menubuttons and Optionmenus
optparse module, Parsing Command-Line Arguments
ORB (Object Request Broker), Python Internet Development Options
ORMs (object relational mappers)
database options, Other Database Options, Python Internet Development Options
functionality, Persistence Options in Python, ORMs: Object Relational Mappers–ORMs: Object Relational Mappers
os module
administrative tools, Administrative Tools
chdir function, Administrative Tools, Current Working Directory
chmod function, Other os module file tools
close function, Bidirectional IPC with anonymous pipes
dup function, Redirecting input and output with subprocess
dup2 function, Bidirectional IPC with anonymous pipes
environ mapping
accessing environment variables, Wrapping C Environment Calls
accessing shell variables, Shell Environment Variables
changing shell variables, Changing Shell Variables
Env object, Adding Wrapper Classes to Flat Libraries
functionality, Other os Module Exports, “I’d Like to Have an Argument, Please”
execl function, os.exec call formats
execle function, os.exec call formats
execlp function, Other os Module Exports, The fork/exec Combination–Spawned child program, os.exec call formats
execlpe function, os.exec call formats
execv function, os.exec call formats
execve function, os.exec call formats
execvp function, os.exec call formats, Bidirectional IPC with anonymous pipes
execvpe function, os.exec call formats
_exit function, os Module Exits
fdopen function, Wrapping descriptors in file objects, Wrapping pipe descriptors in file objects
file tools supported, Lower-Level File Tools in the os Module
fork function
functionality, Other os Module Exports, Forking Processes, Bidirectional IPC with anonymous pipes
os.execlp combination, The fork/exec Combination–Spawned child program
redirecting streams, Redirecting input and output with subprocess
forking tools, Forking Processes
functionality, System Scripting Overview, Python System Modules, Introducing the os Module
getcwd function, Administrative Tools, “I’d Like to Have an Argument, Please”
getenv function, Shell Variable Fine Points: Parents, putenv, and getenv
getpid function, Administrative Tools, Forking Processes
kill function, Signals, Preventing zombies with signal handlers on Linux
linesep character, Portability Constants
listdir function
fetching list of remote files, Downloading Site Directories
handling Unicode filenames, Handling Unicode Filenames in 3.X: listdir, walk, glob
joining files, Joining Files Portably
printing Unicode filenames, Printing Unicode Filenames
storing local files, Uploading Site Directories
walking directory trees, Recursive os.listdir traversals
walking one directory, The os.listdir call
lseek function, Lower-Level File Tools in the os Module
mkdir function, Other os Module Exports
mkfifo function, Other os Module Exports, Named pipe basics
open function, Other os Module Exports, Lower-Level File Tools in the os Module, Using os.open files–os.open mode flags
pathsep character, Portability Constants
pipe function
file descriptors and, Anonymous pipe basics
functionality, Other os Module Exports, Bidirectional IPC with anonymous pipes
redirecting output, Redirecting input and output with subprocess
popen function
communicating with, Communicating with shell commands
exit status, Exit status with os.system and os.popen
functionality, Running Shell Commands from Scripts
launching mail program, SMTP: Sending Email
redirecting streams, Other Redirection Options: os.popen and subprocess Revisited, Redirecting input or output with os.popen
shell listing command, Running shell listing commands with os.popen–Running shell listing commands with os.popen
standard streams and, “I’d Like to Have an Argument, Please”
portability constants, Portability Constants
program exits, os Module Exits
putenv function, Shell Variable Fine Points: Parents, putenv, and getenv, Wrapping C Environment Calls
read function, Lower-Level File Tools in the os Module
remove function, Other os Module Exports, Other os module file tools
rename function, Other os module file tools
sep character, Portability Constants
shell commands from scripts, Running Shell Commands from Scripts–Shell command limitations
spawnv function, Other os Module Exports, Changing Shell Variables, The os.spawn Calls–The os.spawn Calls
spawnve function, Changing Shell Variables, The os.spawn Calls–The os.spawn Calls
startfile function, The os.startfile call
stat function, Other os Module Exports, Other os module file tools, Handling private files and errors
system function, Running Shell Commands from Scripts, Communicating with shell commands, Exit status with os.system and os.popen
tools by functional area, Tools in the os Module
unlink function, Other os module file tools
walk function
find function and, Rolling Your Own find Module
functionality, Other os Module Exports
handling Unicode filenames, Handling Unicode Filenames in 3.X: listdir, walk, glob
scanning directory trees, The os.walk visitor–The os.walk visitor, Scanning the Standard Library Tree
write function, Lower-Level File Tools in the os Module
os.path module
abspath function, Common os.path Tools
functionality, Python System Modules
isdir function, Common os.path Tools
isfile function, Common os.path Tools
join function, Common os.path Tools
samefile function, Handling private files and errors
split function, Common os.path Tools, Handling client path formats
tools supported, Tools in the os Module, Common os.path Tools–Common os.path Tools
Output class, Redirecting Streams to Python Objects
output files, Output files–Closing
output stream buffering
deadlocks and flushes, Output stream buffering revisited: Deadlocks and flushes–Output stream buffering revisited: Deadlocks and flushes
Pexpect and, Redirecting input and output with subprocess, Output stream buffering revisited: Deadlocks and flushes
program exits and, Output stream buffering: A first look
pty module and, Output stream buffering revisited: Deadlocks and flushes

P

Pack class, One More for Old Times’ Sake
packer geometry manager
combining with grid, Combining grid and pack–Combining grid and pack
defined, Geometry Managers
expand and fill options, The Packer’s Expand and Fill Revisited
grid comparison, Comparing grid and pack–Comparing grid and pack
layout system, Layout: Packing Order and Side Attachments
making expandable, Making Gridded Widgets Expandable
resizing widgets, Widget Resizing Basics
packing
scroll bars, Packing Scroll Bars
widgets without saving, Packing Widgets Without Saving Them–Packing Widgets Without Saving Them
paging script example, A Custom Paging Script
PanedWindow widget class, Other Widgets and Options
parallel processing
defined, “Telling the Monkeys What to Do”
forking processes, Forking Processes–Spawned child program
IPC support, Interprocess Communication–Signals
multiprocessing module, The multiprocessing Module–Why multiprocessing? The Conclusion
portable framework, A Portable Program-Launch Framework
program exits, Program Exits–Thread Exits and Shared State
socket server portability and, Why multiprocessing doesn’t help with socket server portability–Why multiprocessing doesn’t help with socket server portability
spawning clients, Spawning Clients in Parallel–Preview: Denied client connections
starting programs, Other Ways to Start Programs–The os.startfile call
system tools coverage, Other System Tools Coverage
threads, Threads–A process-based alternative: multiprocessing (ahead)
parameters
passing in hidden fields, Passing Parameters in Hidden Form Fields
passing in hidden form fields, Hidden Form Input Fields
passing in URLs, Passing parameters in URLs–Passing parameters in URLs, Passing Parameters in Hardcoded URLs–Passing Parameters in Hardcoded URLs, Passing State Information in URL Link Parameters–Passing State Information in URL Link Parameters
query, Internet addresses (URLs), URL Query Parameters
parent process, Forking Processes
parsing
binary data, Parsing packed binary data with the struct module–Parsing packed binary data with the struct module
command-line arguments, Parsing Command-Line Arguments
custom language parsers
adding parse tree interpreter, Adding a Parse Tree Interpreter–Adding a Parse Tree Interpreter
expression grammar, The Expression Grammar
parse tree structure, Parse Tree Structure
parser code, The Parser’s Code–Adding a Parse Tree Interpreter
parser comparisons, Parsers Versus Python
PyTree GUI and, Exploring Parse Trees with the PyTree GUI–Exploring Parse Trees with the PyTree GUI
writing, Custom Language Parsers
defined, “See Jack Hack. Hack, Jack, Hack”
email content, email: Parsing and Composing Mail Content–Summary: Solutions and workarounds
HTML support, Python Internet Development Options, XML and HTML Parsing, HTML Parsing in Action–Extracting plain text from HTML (revisited)
parser decoding requirement, Parser decoding requirement–Parser decoding requirement
recursive descent, Advanced Language Tools, Custom Language Parsers
regular expression support, Regular expression parsing
rule strings, Parsing and Unparsing Rule Strings–More on the holmes expert system shell
with splits and joins, Parsing with Splits and Joins
XML support, Python Internet Development Options, XML and HTML Parsing, XML Parsing in Action–Other XML topics
passwords
encrypting, POP Password Encryption–Rolling your own encryptor
escaping in HTML, Escaping Mail Text and Passwords in HTML–Escaping Mail Text and Passwords in HTML
PyMailCGI password page, The POP Password Page
pattern matching (see regular expressions)
pattern objects (re module), First Examples
performance
PyMailCGI program and, The Web Versus the Desktop
PyMailGUI program and, Ideas for Improvement, The Web Versus the Desktop
saving thumbnail files, Performance: Saving thumbnail files–Performance: Saving thumbnail files
stacks and, Customization: Performance Monitors, More on performance analysis
string object methods and, More on the holmes expert system shell
threads and, Threads
Perl language, Enter Python, In the Final Analysis…
permissions
CGI scripts and, Handling private files and errors
HTML constraints, HTML file permission constraints
persistence
DBM files, DBM Files–DBM Details: Files, Portability, and Close
object relational mappers, ORMs: Object Relational Mappers–ORMs: Object Relational Mappers
options available, Persistence Options in Python
pickled objects, Pickled Objects–Pickle Details: Protocols, Binary Modes, and _pickle
programming considerations, Adding Persistence–Adding Persistence
shelve files, Shelve Files–Other Shelve Limitations
SQL databases, SQL Database Interfaces–SQL Resources
ZODB system, The ZODB Object-Oriented Database–The Mostly Missing ZODB Tutorial
Peters, Tim, The End of the Demo
Pexpect package
output stream buffering and, Redirecting input and output with subprocess, Output stream buffering revisited: Deadlocks and flushes
overview, Python System Modules
PhotoImage widget class, The End of the Tutorial, Images–Fun with Buttons and Pictures, Windows with Both Menus and Toolbars
pickle module
background information, More on the holmes expert system shell
constraints, Pickled Class Constraints–Pickled Class Constraints
functionality, Using Pickle Files–Using Pickle Files, Python’s Internet Library Modules, Pickled Objects
per-record pickle files, Using Per-Record Pickle Files–Using Per-Record Pickle Files
Pickler class, Using Object Pickling
PyMailGUI program and, Ideas for Improvement
Unpickler class, Using Object Pickling
pickled objects
defined, Persistence Options in Python, Pickled Objects
usage considerations, Using Object Pickling–Pickle Details: Protocols, Binary Modes, and _pickle
PIL (Python Imaging Library) extension toolkit
animation and, Graphics and gaming toolkits
basics overview, PIL Basics
creating image thumbnails, Creating Image Thumbnails with PIL–Scrolling and canvases (ahead)
displaying other image types, Displaying Other Image Types with PIL–Displaying all images in a directory
functionality, Python GUI Development Options, tkinter Extensions
images in toolbars, Using images in toolbars, too
thumbnail support, Scrollable Canvases and Image Thumbnails
pipe character (|), Chaining programs with pipes
Pipe object (multiprocessing), IPC Tools: Pipes, Shared Memory, and Queues
pipes
anonymous, Interprocess Communication, Anonymous Pipes–Output stream buffering revisited: Deadlocks and flushes
command-line, Output stream buffering revisited: Deadlocks and flushes, Adding a GUI As a Separate Program: Command Pipes–Other uses for threaded pipe GUIs, Buffering in other contexts: Command pipes revisited, Sockets versus command pipes
implementing, Anonymous Pipes
multiprocessing module and, multiprocessing pipes
named, Interprocess Communication, Named Pipes (Fifos)–Named pipe use cases
sockets and, Sockets and pipes: Compare and contrast
unbuffered modes, Output stream buffering revisited: Deadlocks and flushes
playfile module, Playing the Monty Python theme song
Plone website builder, Python Internet Development Options
plotting points on a circle, A Quick Geometry Lesson–A Quick Geometry Lesson
PLY parsing system, Advanced Language Tools
Pmw (Python Mega Widgets) extension toolkit
functionality, Python GUI Development Options, tkinter Extensions
scrolling support, Scrolling and canvases (ahead)
polymorphism, Redirecting Streams to Python Objects
POP (Post Office Protocol)
fetching email at interactive prompt, Fetching Email at the Interactive Prompt
mail configuration module, Mail Configuration Module–POP Mail Reader Script
mail reader script, POP Mail Reader Script–Fetching Messages
overview, POP: Fetching Email
PyMailCGI and, Reading POP Email–Escaping Mail Text and Passwords in HTML, Deletions and POP Message Numbers–Alternative: Delete on load, POP Mail Interface–Rolling your own encryptor
PyMailGUI and, POP Message Numbers and Synchronization–POP Message Numbers and Synchronization
poplib module
functionality, Python’s Internet Library Modules, Unicode in Python 3.X and Email Tools
mail reader script, POP Mail Reader Script
pymail script and, A Console-Based Email Client
PyMailCGI program and, Implementation Overview, The Message View Page
popmail script, POP: Fetching Email, POP Mail Reader Script–Fetching Messages
port numbers
defined, Machine identifiers
protocol rules, Port number rules
reserved, Talking to Reserved Ports–Binding reserved port servers
pprint module
displaying databases, Dictionaries of dictionaries
regular expression parsing and, Regular expression parsing
SAX parsing and, SAX parsing
scanning directory trees, Scanning the Standard Library Tree
print function
CGI scripts and, Debugging CGI scripts
functionality, Paging Documentation Strings
redirecting, Redirection Syntax in Print Calls
standard streams and, Standard Streams
printing
dialog results, Printing dialog results and passing callback data with lambdas–Printing dialog results and passing callback data with lambdas
Unicode filenames, Printing Unicode Filenames–Printing Unicode Filenames
Process class (multiprocessing), The Basics: Processes and Locks
process forking (see forking processes)
program execution
automated program launchers, Automated Program Launchers (External)
CGI scripts, Installing CGI scripts
cross-program communication, Cross-program communication
GUI programs, Running GUI Programs, Running Programs–Coding for reusability
launching email programs, SMTP: Sending Email
launching methods, Other Ways to Start Programs–The os.startfile call
persistence options, Persistence Options in Python
PyCalc program, Running PyCalc
pymail console client, Running the pymail Console Client–Running the pymail Console Client, Running the pymail2 console client–Running the pymail2 console client
PyMailGUI, Running PyMailGUI
server-side scripts, Running Server-Side Examples–Viewing Server-Side Examples and Output
threads and, Threads
program exits
with child threads, Program exit with child threads
os module, os Module Exits
process exit status and shared state, Process Exit Status and Shared State
shell commands and, Shell Command Exit Status Codes–Exit status with subprocess
sys module, sys Module Exits–sys Module Exits
thread exits and shared state, Thread Exits and Shared State–Thread Exits and Shared State
programming Python
adding behavior, Adding Behavior
adding GUI, Step 5: Adding a GUI–Future directions
adding inheritance, Adding Inheritance
adding persistence, Adding Persistence–Adding Persistence
adding web-based interfaces, Step 6: Adding a Web Interface–Future directions
alternative database options, Other Database Options
class considerations, Using Classes–Using Classes
coding for reusability, Coding for reusability–Coding for reusability
console interaction, Step 4: Adding Console Interaction–A Console Shelve Interface
Hello World program, “Hello World” in Four Lines (or Less), One More for Old Times’ Sake
inputting user data, Getting Input from a User
Internet development options, Python Internet Development Options–Python Internet Development Options
OOP considerations, Step 3: Stepping Up to OOP–Other Database Options
programming pointers, Start-up pointers
rapid development features, But What About That Bottleneck?–Python Fosters Hybrid Applications
refactoring code, Augmenting methods–Alternative classes
representing records, Step 1: Representing Records–Dictionaries of dictionaries
socket programming, Socket Programming–Binding reserved port servers
storing records persistently, Step 2: Storing Records Persistently–Using Shelves
programs, Changing Shell Variables
(see also spawned programs)
chaining with pipes, Chaining programs with pipes
independent, Sockets and independent programs, Starting Independent Programs
redirecting streams to, Redirecting Streams to Files and Programs–Coding alternatives for adders and sorters
protocols
client/server considerations, Clients and servers
defined, The Protocol Layer
development options, Python Internet Development Options
pickle module and, Pickle Details: Protocols, Binary Modes, and _pickle
port number rules, Port number rules
standards overview, Python’s Internet Library Modules
structural considerations, Protocol structures
PSF (Python Software Foundation), Other Database Options
PSP (Python Server Pages), Python Internet Development Options, Keeping display and logic separate, Extensions to the CGI Model
pty module, Output stream buffering revisited: Deadlocks and flushes
putfile module, Playing the Monty Python theme song
PY extension, Avoiding DOS consoles on Windows
py2exe tool, Python GUI Development Options
PyArg_Parse API function, Running Code Strings with Results and Namespaces, Calling Python Objects
Py_BuildValue API function, Calling Python Objects
PyCalc program
adding buttons, Adding new buttons in new components–Adding new buttons in new components
building GUI, Building the GUI
CalcGui class, Running PyCalc, Evaluating expressions with stacks
as component, Using PyCalc as a component–Using PyCalc as a component
Evaluator class, Evaluating expressions with stacks
extending and attaching, Extending and attaching
functionality, PyCalc: A Calculator Program/Object–Building the GUI, PyCalc—A “Real” Calculator GUI
running, Running PyCalc
running code strings, Running code strings
source code, PyCalc source code–Using PyCalc as a component
PyClock program
functionality, PyClock: An Analog/Digital Clock Widget
plotting points on a circle, A Quick Geometry Lesson–A Quick Geometry Lesson
running, Running PyClock–Running PyClock
source code, PyClock Source Code–PyClock Source Code
widget support, Text
Py_CompileString API function, Precompiling Strings to Bytecode
PyCrypto system, POP Password Encryption, Manual data encryption: PyCrypto
PyDemos launcher toolbar, PyDemos Launcher Bar (Mostly External)–PyDemos Launcher Bar (Mostly External), This Chapter’s Strategy, Multiple Windows and Status Messages
PyDict_GetItemString API function, The C Embedding API, Running Strings in Dictionaries
PyDict_New API function, The C Embedding API, Running Strings in Dictionaries
PyDict_SetItemString API function, The C Embedding API, Running Strings in Dictionaries
PyDoc system, Paging Documentation Strings
PyDraw paint program
functionality, PyDraw: Painting and Moving Graphics
running, Running PyDraw
source code, PyDraw Source Code–PyClock: An Analog/Digital Clock Widget
widget support, Text
PyEdit text editor
changes in version 2.0
configuration module, Configuration module
font dialog, Font dialog
summarized, PyEdit Changes in Version 2.0 (Third Edition)
undo, redo, modified tests, Undo, redo, and modified tests
changes in version 2.1
improvements for running code, Improvements for running code
modal dialog state fix, Modal dialog state fix
new Grep dialog, New Grep dialog: Threaded and Unicode-aware file tree search–Grep Unicode model
Quit checks, Cross-process change tests on Quit, More on Quit checks: The <Destroy> event revisited
summarized, PyEdit Changes in Version 2.1 (Fourth Edition)
Unicode text support, Unicode (Internationalized) text support–Unicode options and choices
update for initial positioning, Update for initial positioning
embedding in PyView, Embedding PyEdit in PyView–Embedding PyEdit in PyView
examples and screenshots, Other PyEdit examples and screenshots in this book
functionality, Frame- and Menubutton-Based Menus, PyEdit: A Text Editor Program/Object
implementing, Text
launching, Running PyEdit
menus and toolbars, Menus and toolbars
multiple windows, Multiple windows–Multiple windows
PyMailGUI program and, Sending Email and Attachments
running program code, Running program code
source code
launch files, Windows (and other) launch files
main implementation file, Main implementation file–PyPhoto: An Image Viewer and Resizer
overview, PyEdit Source Code
user configuration file, User configurations file
Unicode support, Supporting Unicode in PyEdit (ahead)
PyEnchant third-party package, Ideas for Improvement
PyErrata website, Other Approaches
PyEval_CallObject API function, The C Embedding API, Calling Python Objects
PyEval_EvalCode API function, Precompiling Strings to Bytecode
PyEval_GetBuiltIns API function, Running Strings in Dictionaries
PyForm example, PyForm: A Persistent Object Viewer (External)–PyForm: A Persistent Object Viewer (External)
PyFort system, Other Extending Tools
PyGadgets launcher toolbar, PyGadgets Launcher Bar–PyGadgets Launcher Bar, This Chapter’s Strategy, Multiple Windows and Status Messages
PyGame package, Graphics and gaming toolkits
PyGTK package, Python GUI Development Options
PyImport_GetModuleDict API function, The C Embedding API
PyImport_ImportModule API function, The C Embedding API, Running Code Strings with Results and Namespaces, Calling Python Objects
Py_Initialize API function, Running Code Strings with Results and Namespaces
PyInstaller tool, Python GUI Development Options
pyjamas toolkit, Python GUI Development Options
pymail console client
functionality, A Console-Based Email Client–Running the pymail Console Client, Why PyMailGUI?
updating, Updating the pymail Console Client–Running the pymail2 console client
PyMailCGI program
background information, “Things to Do When Visiting Chicago”, The PyMailCGI Website
configuring, Configuring PyMailCGI
fourth edition enhancements, New in This Fourth Edition (Version 3.0)–New in the Prior Edition (Version 2.0)
implementation overview, Implementation Overview–Implementation Overview
presentation overview, Presentation Overview
processing fetched mail
delete action, Delete–Delete
deletions/POP message numbers, Deletions and POP Message Numbers–Alternative: Delete on load
overview, Processing Fetched Mail–Processing Fetched Mail
reply and forward, Reply and Forward
reading POP email
escaping mail text/passwords, Escaping Mail Text and Passwords in HTML–Escaping Mail Text and Passwords in HTML
mail selection list page, The Mail Selection List Page–The Mail Selection List Page
message view page, The Message View Page–The Message View Page
passing state information, Passing State Information in URL Link Parameters–Passing State Information in URL Link Parameters, Passing State Information in HTML Hidden Input Fields
POP password page, The POP Password Page
security protocols, Security Protocols
root page, Implementation Overview, The Root Page–Configuring PyMailCGI
running chapter examples, Running This Chapter’s Examples–Running This Chapter’s Examples
sending mail by SMTP
common look-and-feel, Common Look-and-Feel
error pages, Error Pages
message composition page, The Message Composition Page–The Message Composition Page
overview, Sending Mail by SMTP
send mail script, The Send Mail Script–The Send Mail Script, Using the Send Mail Script Outside a Browser–Using the Send Mail Script Outside a Browser
third edition enhancements, New in the Prior Edition (Version 2.0)–New in the Prior Edition (Version 2.0)
utility modules
common utilities module, Common Utilities Module–Web Scripting Trade-Offs
configuration, External Components and Configuration
external components, External Components and Configuration
overview, Utility Modules
POP mail interface, POP Mail Interface
POP password encryption, POP Password Encryption–Rolling your own encryptor
Web scripting tradeoffs
alternative approaches, Other Approaches–Other Approaches
PyMailGUI versus, PyMailCGI Versus PyMailGUI
Web versus desktop, The Web Versus the Desktop–The Web Versus the Desktop
PyMailGUI program
components
altconfigs module, Alternative Configurations and Accounts, altconfigs: Configuring for Multiple Accounts–altconfigs: Configuring for Multiple Accounts, Ideas for Improvement
functionality, A PyMailGUI Demo
html2text module, html2text: Extracting Text from HTML (Prototype, Preview)–mailconfig: User Configurations, Ideas for Improvement
implementation overview, PyMailGUI Implementation–PyMailGUI Implementation
ListWindows module, ListWindows: Message List Windows–ViewWindows: Message View Windows, Ideas for Improvement
mailconfig module, Loading Mail, Sending Email and Attachments, Mail Content Internationalization Support, mailconfig: User Configurations–textConfig: Customizing Pop-Up PyEdit Windows, Ideas for Improvement
main module, PyMailGUI: The Main Module–SharedNames: Program-Wide Globals
messagecache module, messagecache: Message Cache Manager–popuputil: General-Purpose GUI Pop Ups
popuputil module, popuputil: General-Purpose GUI Pop Ups–wraplines: Line Split Tools
PyMailGUIHelp program, PyMailGUIHelp: User Help Text and Display–altconfigs: Configuring for Multiple Accounts
SharedNames module, SharedNames: Program-Wide Globals
textconfig module, textConfig: Customizing Pop-Up PyEdit Windows
ViewWindows module, ViewWindows: Message View Windows–messagecache: Message Cache Manager
wraplines module, wraplines: Line Split Tools–html2text: Extracting Text from HTML (Prototype, Preview)
deleting email, Deleting Email–Deleting Email
email recipient options, Email Replies and Forwards and Recipient Options–Email Replies and Forwards and Recipient Options
email replies and forwards, Email Replies and Forwards and Recipient Options–Email Replies and Forwards and Recipient Options
extracting plain text, Extracting plain text from HTML (revisited)
frame-based menus, Frame- and Menubutton-Based Menus
getting started, Getting Started–Getting Started
HTML content in email, Handling HTML Content in Email
improvement suggestions, Ideas for Improvement–Ideas for Improvement
load server interface, Load Server Interface
loading mail, Loading Mail
mail content Internationalization, New in Version 3.0 (Fourth Edition), Mail Content Internationalization Support–Mail Content Internationalization Support
major changes, Major PyMailGUI Changes–Version 3.0 Unicode support policies
multiple windows, Multiple Windows and Status Messages–Multiple Windows and Status Messages
offline processing, Offline Processing with Save and Open–Offline Processing with Save and Open
overview, Why PyMailGUI?–Why PyMailGUI?
placing callbacks on queues, Placing Callbacks on Queues–Passing bound method callbacks on queues
POP support, POP Message Numbers and Synchronization–POP Message Numbers and Synchronization
presentation strategy, Presentation Strategy
PyMailCGI versus, PyMailCGI Versus PyMailGUI
running, Running PyMailGUI
sending email and attachments, Sending Email and Attachments–Sending Email and Attachments
source code modules and size, Source Code Modules and Size–Code Structure
status messages, Multiple Windows and Status Messages–Multiple Windows and Status Messages
synchronization, POP Message Numbers and Synchronization–POP Message Numbers and Synchronization
threading model, Threading Model–Threading model implementation
Unicode support policies, Version 3.0 Unicode support policies–Version 3.0 Unicode support policies
viewing email and attachments, Viewing Email and Attachments–Viewing Email and Attachments
PyMailGUIHelp program, PyMailGUIHelp: User Help Text and Display–altconfigs: Configuring for Multiple Accounts
PyModule_GetDict API function, The C Embedding API, Running Code Strings with Results and Namespaces
PyObjC toolkit, Python GUI Development Options
PyObject_CallObject API function, The C Embedding API
PyObject_GetAttrString API function, The C Embedding API, Calling Python Objects, Running Strings in Dictionaries
PyObject_SetAttrString API function, The C Embedding API, Running Code Strings with Results and Namespaces
PyParsing system, Advanced Language Tools
PyPhoto image program
limitations, Scrolling images too: PyPhoto (ahead)
overview, PyPhoto: An Image Viewer and Resizer
running, Running PyPhoto–Running PyPhoto
source code, PyPhoto Source Code–PyView: An Image and Notes Slideshow
widget support, Text
PyPI website, Python Internet Development Options, Advanced Language Tools
PyQt package, Python GUI Development Options
Pyrex system, Extending and Embedding, Other Extending Tools
PyRun_File API function, The C Embedding API
PyRun_SimpleString API function, Running Simple Code Strings
PyRun_String API function, The C Embedding API, Running Code Strings with Results and Namespaces, Running Strings in Dictionaries
pySerial interface, Python System Modules, Using a reusable form-layout class
python interpreter program, Parsing Command-Line Arguments
Python language
Internet development option, Python Internet Development Options–Python Internet Development Options
language comparisons, Enter Python–Enter Python
name origin, Using Shelves
third-party packages, The Next Five Chapters
Python Server Pages (PSP), Python Internet Development Options, Keeping display and logic separate, Extensions to the CGI Model
Python Software Foundation (PSF), Other Database Options
PythonCard builder, Python GUI Development Options
PythonInterpreter class API, Other Integration Topics
PYTHONIOENCODING environment variable, Printing Unicode Filenames
PYTHONPATH environment variable
defined, Shell Environment Variables
pickled class constraints, Pickled Class Constraints
running code strings, Compiling and running
syntax errors and, The Module Search Path
PYTHONUNBUFFERED environment variable, Installing CGI scripts
PyToe game widget
functionality, PyToe: A Tic-Tac-Toe Game Widget
running, Running PyToe
source code, PyToe Source Code (External)–PyToe Source Code (External)
PyTree program, Scrolling Canvases, PyTree: A Generic Tree Object Viewer–PyTree: A Generic Tree Object Viewer, Exploring Parse Trees with the PyTree GUI–Exploring Parse Trees with the PyTree GUI
PyView image program
frame-based menus, Frame- and Menubutton-Based Menus
functionality, PyView: An Image and Notes Slideshow
running, Running PyView–Embedding PyEdit in PyView
source code, PyView Source Code–PyView Source Code
widget support, Text
PYW extension, Avoiding DOS consoles on Windows
PyWin32 package
development options, Python Internet Development Options
overview, Python GUI Development Options
PyXML SIG, Other XML topics

Q

queries
automating, Automating with scripts and modules–Automating with scripts and modules
CGI script support, Using Query Strings and urllib–Using Query Strings and urllib
parameter considerations, Internet addresses (URLs), URL Query Parameters
running with SQLite, Running queries–Running queries
QUERY_STRING environment variable, Step 3: Putting It All Together—A New Reply Script
queue module
arguments versus globals, Arguments versus globals
functionality, Python System Modules, The queue Module
program exit with child threads, Program exit with child threads
running the script, Running the script
threads and, Threads
Queue object (multiprocessing), IPC Tools: Pipes, Shared Memory, and Queues, Queues and subclassing–Queues and subclassing
queues
placing callbacks on, Placing Callbacks on Queues–Passing bound method callbacks on queues
placing data on, Placing Data on Queues–Thread exits in GUIs
Quit button, A “smart” and reusable Quit button
quit method, tkinter Coding Basics
quopri module, Python’s Internet Library Modules

R

Radiobutton widget class
associated variables, Checkbuttons
command option, Radio Buttons
functionality, The End of the Tutorial, Radio Buttons–Hold onto your variables!
variables and, Radio buttons and variables–Radio buttons and variables
random access files, Random access files–Random access files
random module, Future directions, Fun with Buttons and Pictures
range function, Field labels
re module
compile function, First Examples, Module functions, Compiled pattern objects
escape function, Module functions
findall function, First Examples, String Operations Versus Patterns, Module functions, Regular expression parsing
finditer function, Module functions
functionality, The re Module
match function, First Examples, String Operations Versus Patterns, Module functions, Match objects
search function, First Examples, String Operations Versus Patterns, Module functions, Match objects
sub function, Module functions
subn function, Module functions
records
adding with SQLite, Adding records
building dictionaries, Building Record Dictionaries–Automating with scripts and modules
built-in dictionaries, Using Dictionaries–Dictionaries of dictionaries
formatted files, Using Formatted Files–Utility scripts
list-based, Using Lists–Field labels
per-record pickle files, Using Per-Record Pickle Files–Using Per-Record Pickle Files
pickle files, Using Pickle Files–Using Pickle Files
shelves and, Using Shelves–Using Shelves
recursive descent parsing, Advanced Language Tools, Custom Language Parsers
refactoring code
alternative classes, Alternative classes
augmenting methods, Augmenting methods
with CGI scripts, Refactoring Code for Maintainability–Step 3: Putting It All Together—A New Reply Script
with classes, Refactoring with classes–Refactoring with classes
constructor customization, Constructor customization
display format, Display format
with functions, Refactoring with functions–Refactoring with functions
Register_Handler function, Registration Implementation
regression test scripts, A Regression Test Script–Running the Test Driver
regular expressions
defined, Regular Expression Pattern Matching
limitations, Advanced Language Tools
parsing support, Regular expression parsing
pattern examples, More Pattern Examples–More Pattern Examples
pattern matching techniques, First Examples–First Examples
pattern syntax, Regular expression patterns–Regular expression patterns
re module, The re Module, Using the re Module–Regular expression patterns
scanning C header files, Scanning C Header Files for Patterns–Scanning C Header Files for Patterns
string operations versus, String Operations Versus Patterns–String Operations Versus Patterns
remote sites
deleting remote trees, Deleting Remote Trees–Deleting Remote Trees
downloading directories, Downloading Site Directories–Downloading Site Directories
downloading remote trees, Downloading Remote Trees
remote servers, Socket pragmatics, Finding Python on remote servers
uploading directories, Uploading Site Directories–Uploading Site Directories
repeater method, Using the after Method
ReplaceVisitor class, Global Replacements in Directory Trees (Visitor)
reporting directory differences, Reporting Differences and Other Ideas–Reporting Differences and Other Ideas
reserved port numbers, Talking to Reserved Ports–Binding reserved port servers
RETR string (FTP), FTP get and put Utilities
RFC822, Processing Internet Email
rfc822 module, Basic email Package Interfaces in Action
RIAs (rich Internet applications), Python GUI Development Options, Python Internet Development Options, Other Approaches
rotor module, Manual data encryption: rotor (defunct)
Route_Event function, Registration Implementation
rule strings, parsing/unparsing, Parsing and Unparsing Rule Strings–More on the holmes expert system shell
running programs (see program execution)

S

SAX parsers, XML and HTML Parsing, SAX parsing
Scale widget class
command option, Scales (Sliders)
from_ option, Scales (Sliders)
functionality, The End of the Tutorial, Scales (Sliders)–Scales and variables
get/set methods, Scales (Sliders)
label option, Scales (Sliders)
resolution option, Scales (Sliders)
showvalue option, Scales (Sliders)
tickinterval option, Scales (Sliders)
to option, Scales (Sliders)
variables and, Scales and variables–Scales and variables
scanner function, File Scanners
scanning
C header files for patterns, Scanning C Header Files for Patterns–Scanning C Header Files for Patterns
directories, Scanning the Standard Library Directory
directory trees, Scanning the Standard Library Tree
entire machines, Scanning the Entire Machine–Scanning the Entire Machine
module search paths, Scanning the Module Search Path–Scanning the Module Search Path
Scheme language, Enter Python
SciPy package, Other Extending Tools
screen scraping, Python Internet Development Options, Testing outside browsers with the module urllib.request
scripts, CGI Basics
(see also CGI scripts; client-side scripting; Internet-related scripting; network scripting; server-side scripting; system programs; system scripting)
automating queries, Automating with scripts and modules–Automating with scripts and modules
command-line arguments and, Command-Line Arguments–Parsing Command-Line Arguments
command-line mode, Using the scripts–Using the scripts
current working directory and, Current Working Directory–CWD and Command Lines
custom paging script, A Custom Paging Script
data format script, Data format script–Data format script
launching, Current Working Directory
queue module example, Running the script
refactoring with classes, Refactoring with classes–Refactoring with classes
refactoring with functions, Refactoring with functions–Refactoring with functions
regression test, A Regression Test Script–Running the Test Driver
running shell commands from, Running Shell Commands from Scripts–Shell command limitations
shell variables and, Shell Environment Variables–Shell Variable Fine Points: Parents, putenv, and getenv
SQL utility, SQL Utility Scripts–Using the scripts
standard streams and, Standard Streams–Redirecting input and output with subprocess
start command in, Using start in Python scripts
start-up pointers, Script start-up pointers
test data script, Test data script
Unix platforms and, Parsing Command-Line Arguments
utility scripts, Utility scripts
Web tradeoffs, Web Scripting Trade-Offs–Other Approaches
Scrollbar widget class
functionality, The End of the Tutorial, Listboxes and Scrollbars
packing scroll bars, Packing Scroll Bars
programming, Programming Scroll Bars
set method, Programming Scroll Bars
ScrolledCanvas class, Scrolling Canvases–Scrolling Canvases
ScrolledList component class, Listboxes and Scrollbars
ScrolledText component class, Text, Adding Text-Editing Operations, Composition versus inheritance
search paths, CGI scripts, Installing CGI scripts
search_all script, Visitor: Walking Directories “++”
searcher function, A Python Tree Searcher
searching directory trees, Searching Directory Trees–A Python Tree Searcher
SearchVisitor class, Visitor: Walking Directories “++”–Visitor: Walking Directories “++”, Using mimetypes guesses for SearchVisitor
Secure Sockets Layer (SSL), Security Protocols
security
password encryption and, POP Password Encryption–Rolling your own encryptor
PyMailCGI program and, Configuring PyMailCGI, Security Protocols
web-based interfaces and, Directories, string formatting, and security–Directories, string formatting, and security
select module
functionality, Python System Modules
multiplexing servers, Multiplexing Servers with select–Summary: Choosing a Server Scheme
sendmail program, SMTP: Sending Email
sequences
permuting, Permuting Sequences–Permuting Sequences
reversing/sorting, Reversing and Sorting Sequences–Data Structures Versus Built-ins: The Conclusion
serial port interfaces, Using a reusable form-layout class
serialization, Pickled Objects
server-side databases, Server-Side Databases
server-side scripting/processing, “Oh, What a Tangled Web We Weave”
(see also CGI scripts; PyMailCGI program)
development options, Python Internet Development Options
forking servers, Forking Servers–Why multiprocessing doesn’t help with socket server portability
Internet applications and, Other Approaches
multiplexing servers with select, Multiplexing Servers with select–Summary: Choosing a Server Scheme
overview, “Oh, What a Tangled Web We Weave”
protocol considerations, Clients and servers
Python file server, A Simple Python File Server–Using a reusable form-layout class
root page examples, The Server-Side Examples Root Page
running, Running Server-Side Examples–Viewing Server-Side Examples and Output
server socket calls, Server socket calls–Server socket calls
templating languages, Writing CGI Scripts in Python
threading servers, Threading Servers–Threading Servers
transferring files, Transferring Files to Clients and Servers–More Than One Way to Push Bits over the Net
sets
adding relational algebra, Adding Relational Algebra to Sets (External)
built-in options, Built-in Options
classes and, Set Classes–Set Classes
defined, Implementing Sets
functions and, Set Functions–Supporting multiple operands
moving to dictionaries, Optimization: Moving Sets to Dictionaries–Timing the results under Python 3.1
operations supported, Implementing Sets
shared memory
mmap module, Interprocess Communication
multiprocessing module and, Shared memory and globals–Shared memory and globals
threads and, Threads
shared state
forking processes and, Process Exit Status and Shared State
threads and, Thread Exits and Shared State–Thread Exits and Shared State
shell commands
communicating with, Communicating with shell commands
defined, What’s a shell command?
exit status codes, Shell Command Exit Status Codes–Exit status with subprocess
find, Greps and Globs and Finds
kill, Signals
limitations, Shell command limitations
os module support, Running Shell Commands from Scripts
running, Running shell commands
subprocess module alternative, The subprocess module alternative–The subprocess module alternative
shell variables
accessing, “I’d Like to Have an Argument, Please”
changing, Changing Shell Variables
defined, Shell Environment Variables
environment settings, Shell Variable Fine Points: Parents, putenv, and getenv
fetching, Fetching Shell Variables
wrapping calls, Wrapping C Environment Calls–Wrapping C Environment Calls with SWIG
ShellGui tool
adding GUI frontends to command lines, Adding GUI Frontends to Command Lines–Room for improvement
application-specific tool set classes, Application-Specific Tool Set Classes
functionality, ShellGui: GUIs for Command-Line Tools
generic shell-tools display, A Generic Shell-Tools Display–A Generic Shell-Tools Display
GUI input dialogs, GUI input dialogs–GUI input dialogs
non-GUI scripts, Non-GUI scripts–Non-GUI scripts
shelve files
changing classes of objects, Changing Classes of Objects Stored in Shelves
constraints, Shelve Constraints–Underlying DBM format portability
defined, Persistence Options in Python, Shelve Files
standard operations, Using Shelves
storing built-in object types, Storing Built-in Object Types in Shelves
storing class instances, Storing Class Instances in Shelves–Storing Class Instances in Shelves
usage considerations, Using Shelves
shelve module
console interface, A Console Shelve Interface–A Console Shelve Interface
dictionary-of-dictionaries format and, Dictionaries of dictionaries
functionality, Using Shelves–Using Shelves
GUI interface, A GUI Shelve Interface–Future directions
open method, Using Shelves
pickle support and, Shelve Files
PyMailGUI program and, Ideas for Improvement
unique objects and, Objects are unique only within a key
usage considerations, Using Shelves
web-based interfaces, A Web-Based Shelve Interface–Future directions
writeback argument, Using Shelves, Updates must treat shelves as fetch-modify-store mappings
shutil module
additional information, Other os module file tools
functionality, Python System Modules
signal handlers, Preventing zombies with signal handlers on Linux–Preventing zombies with signal handlers on Linux
signal module
alarm function, Signals
functionality, Python System Modules, Signals–Signals
pause function, Signals
signal function, Signals
signals
defined, Interprocess Communication
functionality, Signals–Signals
Silverlight framework, Python GUI Development Options
SimpleEditor class
clipboard support, Using the clipboard
functionality, Adding Text-Editing Operations
inheritance support, Composition versus inheritance
limitations, It’s called “Simple” for a reason: PyEdit (ahead)
SIP system, Other Extending Tools
Smalltalk language, Enter Python
SMTP (Simple Mail Transfer Protocol)
date formatting standard, Manipulating both From and To
mail sender script, SMTP Mail Sender Script–Sending Email at the Interactive Prompt
overview, SMTP: Sending Email
PyMailCGI program, Sending Mail by SMTP–Using the Send Mail Script Outside a Browser
sending email at interactive prompt, Sending Email at the Interactive Prompt
smtplib module
functionality, Python’s Internet Library Modules, Unicode in Python 3.X and Email Tools, SMTP: Sending Email
pymail script and, A Console-Based Email Client
PyMailCGI program and, Implementation Overview
PyMailGUI program and, Sending Email and Attachments, Ideas for Improvement
smtpmail script, SMTP Mail Sender Script–Sending Email at the Interactive Prompt
SOAP
integration considerations, Other Integration Topics
persistence options, Persistence Options in Python
pickled objects and, Using Object Pickling
Web services support, Python Internet Development Options
socket module
functionality, Python System Modules, Sockets: A First Look–Socket use cases, Python’s Internet Library Modules, Python’s Internet Library Modules
programming, Socket Programming–Binding reserved port servers
socket objects
bind method, Server socket calls
close method, Client socket calls
connect method, Client socket calls
defined, Server socket calls
listen method, Server socket calls
makefile method, Output stream buffering revisited: Deadlocks and flushes, Making Sockets Look Like Files and Streams
send method, Client socket calls
setblocking method, Running the select server
sockets
basic functionality, Socket basics–Socket basics, The Socket Layer, Socket Basics–Client socket calls
client calls, Client socket calls
command pipes and, Sockets versus command pipes
defined, Interprocess Communication, What we will cover
development options, Python Internet Development Options
forked processes and, Forked processes and sockets
independent programs and, Sockets and independent programs
looking like files and streams, Making Sockets Look Like Files and Streams–Sockets versus command pipes
machine identifiers, Machine identifiers
output stream buffering and, Output stream buffering revisited: Deadlocks and flushes
pipes and, Sockets and pipes: Compare and contrast
practical usage considerations, Socket pragmatics
programming support, Socket Programming
running programs locally, Running Socket Programs Locally
running programs remotely, Running Socket Programs Remotely–Socket pragmatics
server calls, Server socket calls–Server socket calls
spawning clients in parallel, Spawning Clients in Parallel–Preview: Denied client connections
spawning GUI as separate programs, Adding a GUI As a Separate Program: Sockets (A Second Look)–Adding a GUI As a Separate Program: Sockets (A Second Look)
talking to reserved ports, Talking to Reserved Ports–Binding reserved port servers
transferring byte strings/objects, Transferring byte strings and objects
use cases, Socket use cases
socketserver module, Running a Web Server, Python’s Internet Library Modules, Standard Library Server Classes
sorted function, Coding alternatives for adders and sorters
source code lines, counting, Counting Source Code Lines (Visitor)
spam, Sending Messages, Ideas for Improvement
SPARK toolkit, Advanced Language Tools
spawned programs
command-line pipes, Adding a GUI As a Separate Program: Command Pipes–Other uses for threaded pipe GUIs
defined, Changing Shell Variables
sockets example, Adding a GUI As a Separate Program: Sockets (A Second Look)–Adding a GUI As a Separate Program: Sockets (A Second Look), Spawning Clients in Parallel–Preview: Denied client connections
spawned threads (see threads)
spelling checkers, Ideas for Improvement
Spinbox widget class, Other Widgets and Options
splitting files, Splitting Files Portably–Splitting Files Portably, Usage Variations–Usage Variations
SQL databases
additional resources, SQL Resources
API tutorial with SQLite, An SQL Database API Tutorial with SQLite–Running updates
building record dictionaries, Building Record Dictionaries–Automating with scripts and modules
code consolidation, Tying the Pieces Together–Tying the Pieces Together
functionality, Persistence Options in Python, SQL Database Interfaces–SQL Database Interfaces
interface overview, SQL Interface Overview–SQL Interface Overview
loading database tables from files, Loading Database Tables from Files–Python versus SQL
SQL utility scripts, SQL Utility Scripts–Using the scripts
SQLAlchemy system, Other Database Options, SQL Database Interfaces
SQLite database system
adding records, Adding records
getting started, Getting started
making databases/tables, Making databases and tables
overview, An SQL Database API Tutorial with SQLite
running queries, Running queries–Running queries
running updates, Running updates
SQLObject system, Other Database Options, SQL Database Interfaces, ORMs: Object Relational Mappers
SSL (Secure Sockets Layer), Security Protocols
ssl module, Python’s Internet Library Modules, Security Protocols
stacks
built-in options, Built-in Options–Built-in Options
customizing performance monitors, Customization: Performance Monitors
defined, Implementing Stacks
defining Stack class, A Stack Class–A Stack Class
defining stack module, A Stack Module–A Stack Module
evaluating expressions with, Evaluating expressions with stacks–Evaluating expressions with stacks
in-place list modifications, Optimization: In-Place List Modifications–Optimization: In-Place List Modifications
as lists, Built-in Options
timing improvements, Timing the Improvements–More on performance analysis
tuple tree, Optimization: Tuple Tree Stacks–Optimization: Tuple Tree Stacks
Stajano, Frank, The Next Five Chapters
standard dialogs, Standard (Common) Dialogs–Other standard dialog calls
standard streams (see input/output streams)
start command, Shell command limitations, Using the DOS start command
state information
combining techniques, Combining Techniques
extensions to CGI model, Extensions to the CGI Model
hidden form input fields, Hidden Form Input Fields
HTTP cookies, HTTP “Cookies”–Handling cookies with the urllib.request module
Internet applications and, Other Approaches
passing with PyMailCGI, Implementation Overview, Passing State Information in URL Link Parameters–Passing State Information in URL Link Parameters, Passing State Information in HTML Hidden Input Fields
process exit status, Process Exit Status and Shared State
saving in CGI scripts, Saving State Information in CGI Scripts–Combining Techniques
SAX parsers and, XML and HTML Parsing
server-side databases, Server-Side Databases
thread exits, Thread Exits and Shared State–Thread Exits and Shared State
URL query parameters, URL Query Parameters
status codes, exit, Shell Command Exit Status Codes–Exit status with subprocess
status messages, PyMailGUI program, Multiple Windows and Status Messages–Multiple Windows and Status Messages
STOR string (FTP), FTP get and put Utilities
str object type
functionality, Other String Concepts in Python 3.X: Unicode and bytes
string method calls, String Method Utilities–String Method Utilities
Text widget and, String types in the Text widget–String types in the Text widget
usage considerations, The problem with treating text as bytes–The problem with treating text as bytes
string methods
basics overview, String Method Basics–String Method Basics
endswith method, String Method Utilities
find method, String Method Utilities
format method, String Method Utilities
isdigit method, String Method Utilities
isupper method, String Method Utilities
join method, Common os.path Tools, String Method Utilities, Parsing with Splits and Joins, Parsing and Unparsing Rule Strings
pattern matching versus, String Operations Versus Patterns–String Operations Versus Patterns
performance and, More on the holmes expert system shell
replace method, String Method Utilities, Templating with Replacements and Formats
templating with replacements/formats, Templating with Replacements and Formats
rjust method, String Method Utilities
rstrip method, String Method Utilities
split method, String Method Utilities, Parsing with Splits and Joins, Summing Columns in a File
startswith method, String Method Utilities
strip method, String Method Utilities
summing columns in files, Summing Columns in a File–Summing with dictionaries
upper method, String Method Utilities
string module
ascii_uppercase constant, String Method Utilities
background information, More on the holmes expert system shell
preset variables, String Method Basics
string methods and, String Method Utilities
Template feature, Templating with Replacements and Formats
strings, Regular Expression Pattern Matching
(see also code strings; regular expressions)
converting, String Method Basics, Converting strings in CGI scripts
converting objects to, Pickled Objects
formatting, Directories, string formatting, and security–Directories, string formatting, and security
functionality, Strategies for Processing Text in Python
query, Using Query Strings and urllib–Using Query Strings and urllib
shelve constraints, Keys must be strings (and str)
specifying positions, String positions
Text widget as, Text is a Python string
Unicode text in, Unicode text in strings–Unicode text in strings
StringVar class, tkinter “Variables” and Form Layout Alternatives
strop module, More on the holmes expert system shell
struct module
functionality, Python’s Internet Library Modules
parsing binary data, Parsing packed binary data with the struct module–Parsing packed binary data with the struct module
serial ports and, Using a reusable form-layout class
unpack method, Parsing packed binary data with the struct module
subclassing
attaching class components, Attaching Class Components–Attaching Class Components
attaching frames, Configuring at construction time
built-in types, Subclassing Built-in Types–Subclassing Built-in Types
C++ class, Subclassing the C++ class in Python
customizing widgets with classes, Customizing Widgets with Classes–Common appearance
extending class components, Extending Class Components
multiprocessing module and, Queues and subclassing–Queues and subclassing
protocol considerations, Subclass Protocols
PyCalc program and, PyCalc—A “Real” Calculator GUI
recursive uploads, Uploading Local Trees
reusable GUI components, Reusable GUI Components with Classes–Standalone Container Classes
subprocess module
exit status, Exit status with subprocess
functionality, Python System Modules
Popen object, Other os Module Exports
redirecting streams, Other Redirection Options: os.popen and subprocess Revisited, Redirecting input and output with subprocess–Redirecting input and output with subprocess
SumGrid class, Laying Out Larger Tables with grid
summer function, Summing Columns in a File–Summing with dictionaries
SWIG tool, The SWIG Integration Code Generator–A Simple SWIG Example, Wrapping C Environment Calls with SWIG, Wrapping C++ Classes with SWIG–Exploring the wrappers interactively
synchronization
inbox error potential, Inbox synchronization error potential
mailtools utility package, Inbox synchronization tools
PyMailGUI program and, POP Message Numbers and Synchronization–POP Message Numbers and Synchronization
_thread module and, Synchronizing access to shared objects and names–Synchronizing access to shared objects and names
threading module, Synchronizing access to shared objects and names revisited–Synchronizing access to shared objects and names revisited
threads and, Threads
sys module
argv parameter, “I’d Like to Have an Argument, Please”, Command-Line Arguments
command-line arguments, Command-Line Arguments–Parsing Command-Line Arguments
current working directory, CWD, Files, and Import Paths
documentation sources, Module Documentation Sources
exception details, Exception Details
exc_info function, Exception Details
exit function, sys Module Exits–sys Module Exits
functionality, System Scripting Overview, Python System Modules, Other sys Module Exports
getdefaultencoding function, Unicode encodings for text files
getrefcount function, The Loaded Modules Table
loaded modules table, The Loaded Modules Table
module search path, The Module Search Path, CWD, Files, and Import Paths, Scanning the Module Search Path
modules dictionary, The Loaded Modules Table
platform string, Platforms and Versions
platforms and versions, Platforms and Versions
program exits, sys Module Exits–sys Module Exits, Adding Buttons and Callbacks
setcheckinterval function, More on the Global Interpreter Lock
standard streams and, Standard Streams–Redirecting input and output with subprocess
sys.stderr
capturing stream, Capturing the stderr Stream
CGI scripts and, Debugging CGI scripts
functionality, “I’d Like to Have an Argument, Please”
output stream buffering, Output stream buffering revisited: Deadlocks and flushes
PyMailCGI program and, Common Utilities Module
sys.stdin
CGI scripts and, Writing CGI Scripts in Python
end-of-file character, Redirecting Streams to Files and Programs
end-of-line character, Redirecting Streams to Files and Programs
functionality, “I’d Like to Have an Argument, Please”
redirecting to Python objects, Redirecting Streams to Python Objects–Redirecting Streams to Python Objects
user interaction and, Redirected Streams and User Interaction–Redirected Streams and User Interaction
sys.stdout
CGI scripts and, Writing CGI Scripts in Python
functionality, “I’d Like to Have an Argument, Please”
output stream buffering, Output stream buffering revisited: Deadlocks and flushes
redirecting print calls, Redirection Syntax in Print Calls
redirecting to Python objects, Redirecting Streams to Python Objects–Redirecting Streams to Python Objects
system programs
additional examples, Other Visitor Examples (External)
automated program launchers, Automated Program Launchers (External)
comparing directory trees, Comparing Directory Trees–Reporting Differences and Other Ideas
copying directory trees, Copying Directory Trees
counting source code lines, Counting Source Code Lines (Visitor)
generating redirection web pages, Generating Redirection Web Pages–Page Generator Script
playing media files, Playing Media Files–Running the Script
printing Unicode filenames, Printing Unicode Filenames–Printing Unicode Filenames
recoding copies with classes, Recoding Copies with Classes (Visitor)–Recoding Copies with Classes (Visitor)
regression test scripts, A Regression Test Script–Running the Test Driver
scanning directories, Scanning the Standard Library Directory
scanning directory trees, Scanning the Standard Library Tree
scanning entire machine, Scanning the Entire Machine–Scanning the Entire Machine
scanning module search path, Scanning the Module Search Path–Scanning the Module Search Path
searching directory trees, Searching Directory Trees–A Python Tree Searcher
splitting and joining files, Splitting and Joining Files–Usage Variations
walking directories, Visitor: Walking Directories “++”–Other Visitor Examples (External)
system scripting
additional references, Commercially Published References
bytes string type, Other String Concepts in Python 3.X: Unicode and bytes
custom paging scripts, A Custom Paging Script
file operations and, File Operation Basics
module documentation sources, Module Documentation Sources
overview, System Scripting Overview
paging documentation strings, Paging Documentation Strings
program usage considerations, Using Programs in Two Ways
Python library manuals, Python Library Manuals
string methods, String Method Basics–String Method Basics
system modules, Python System Modules
Unicode encoding, Other String Concepts in Python 3.X: Unicode and bytes
system tools, “Telling the Monkeys What to Do”
(see also parallel processing)
defined, Why Python Here?
os module, Introducing the os Module–Other os Module Exports
sys module, Introducing the sys Module–Other sys Module Exports
system scripting, System Scripting Overview–Commercially Published References
systems application domain, “The os.path to Knowledge”

T

tables
creating with SQLite, Making databases and tables
description considerations, Using table descriptions
generating, Adding Pictures and Generating Tables–Table tags
laying out forms, Using Tables to Lay Out Forms–Debugging CGI scripts
loading from files, Loading Database Tables from Files–Python versus SQL
ORM support, Persistence Options in Python
table display script, Table display script–Table display script
table load script, Table load scripts
tags
binding, Advanced Text and Tag Operations
form, Submission page–More on form tags
objects, Canvas object tags
table, Table tags
text, Text tags
Tcl language, Python/tkinter for Tcl/Tk Converts, Enter Python
Telnet service, Transferring Directories with ftplib, POP: Fetching Email
telnetlib module, Python’s Internet Library Modules
tempfile module, Python System Modules
templating
server-side languages supporting, Writing CGI Scripts in Python, Other Approaches
with replacements and formats, Templating with Replacements and Formats
testparser module, The Expression Grammar, Adding a Parse Tree Interpreter
text files
buffered output streams and, Text-mode files and buffered output streams
end-of-line translations, End-of-line translations for text files–End-of-line translations for text files
Unicode encoding and, The File Object Model in Python 3.X, Binary and Text Files, Unicode encodings for text files–Unicode encodings for text files, Unicode and the Text Widget–Supporting Unicode in PyEdit (ahead)
text payload encodings, Text payload encodings: Handling mixed type results–Text payload encodings: Using header information to decode, Unicode decoding for text part payloads and message headers
text processing and language analysis
advanced language tools, Advanced Language Tools–Adding new buttons in new components
custom language parsers, Custom Language Parsers–Parsers Versus Python
PyCalc program, PyCalc: A Calculator Program/Object
regular expressions, Regular Expression Pattern Matching–Scanning C Header Files for Patterns
strategies for, Strategies for Processing Text in Python
string method utilities, String Method Utilities–More on the holmes expert system shell
XML and HTML parsing, XML and HTML Parsing–Extracting plain text from HTML (revisited)
Text widget class
advanced operations, Advanced Text and Tag Operations–Advanced Text and Tag Operations
functionality, The End of the Tutorial, Text–Text
get method, Text tags
index support, Text indexes
mark_set method, Text marks
programming, Programming the Text Widget–Text tags
PyMailGUI program and, Handling HTML Content in Email, Ideas for Improvement
search method, Text tags
tag support, Text tags
tag_add method, Text tags
tag_bind method, Advanced Text and Tag Operations
tag_delete method, Text tags
tag_remove method, Text tags
text-editing operations, Adding Text-Editing Operations–It’s called “Simple” for a reason: PyEdit (ahead)
Unicode and, Unicode and the Text Widget–Supporting Unicode in PyEdit (ahead)
xscrollcommand option, Programming Scroll Bars
xview method, Programming Scroll Bars
yscrollcommand option, Programming Scroll Bars
yview method, Programming Scroll Bars
text-mode transfers, Uploading Site Directories
this module, The End of the Demo
Thread class, The threading Module
_thread module
allocate_lock function, Synchronizing access to shared objects and names
basic usage, Basic usage–Basic usage
coding alternatives, Coding alternatives: busy loops, arguments, and context managers–Coding alternatives: busy loops, arguments, and context managers
functionality, Python System Modules
running multiple threads, Running multiple threads–Running multiple threads
start_new_thread function, Basic usage
synchronizing access, Synchronizing access to shared objects and names–Synchronizing access to shared objects and names
waiting for spawned thread exits, Waiting for spawned thread exits–Waiting for spawned thread exits
ways to code threads, Other ways to code threads with _thread
threading module
functionality, Python System Modules, The threading Module–The threading Module
synchronizing access, Synchronizing access to shared objects and names revisited–Synchronizing access to shared objects and names revisited
thread exits in GUIs, Thread exits in GUIs
timer function, Preview: GUIs and Threads
ways to code threads, Other ways to code threads with threading
threads
advantages using, Threads
animation and, Threads and animation
anonymous pipes and, Anonymous pipes and threads
exit considerations, Thread Exits and Shared State–Thread Exits and Shared State, Thread exits in GUIs
global interpreter lock and, More on the Global Interpreter Lock–A process-based alternative: multiprocessing (ahead)
GUIs and, Preview: GUIs and Threads–Preview: GUIs and Threads, Using Threads with tkinter GUIs–Using Threads with tkinter GUIs, Updating GUIs within threads…and other nonsolutions
potential usage downsides, Threads
PyEdit text editor, New Grep dialog: Threaded and Unicode-aware file tree search, Grep threading model
PyMailGUI program and, New in Version 3.0 (Fourth Edition), Threading Model–Threading model implementation
queue module, The queue Module–Running the script
servers and, Threading Servers–Threading Servers
shared state, Thread Exits and Shared State–Thread Exits and Shared State
spawned, “Telling the Monkeys What to Do”
_thread module, The _thread Module–Coding alternatives: busy loops, arguments, and context managers
threading module, The threading Module–Synchronizing access to shared objects and names revisited
time.sleep loops, Using multiple time.sleep loop threads
thumbnails, Scrolling images too: PyPhoto (ahead)
(see also PyPhoto image program)
creating, Creating Image Thumbnails with PIL–Scrolling and canvases (ahead)
scrollable canvases and, Scrollable Canvases and Image Thumbnails–Scrolling images too: PyPhoto (ahead)
time module
functionality, Python System Modules
sleep call, Forking Processes, Simple Animation Techniques, Using time.sleep loops–Using time.sleep loops, Using multiple time.sleep loop threads
timeit module, Python System Modules
timer objects, Preview: GUIs and Threads
Tix extension toolkit
functionality, Python GUI Development Options, tkinter Extensions
HList widget, Ideas for Improvement
Tk GUI library, Python/tkinter for Tcl/Tk Converts
Tk widget class
coding example, tkinter Coding Alternatives
destroy method, Top-Level Window Protocols
exporting methods, Top-Level Window Protocols–Top-Level Window Protocols
functionality, The End of the Tutorial, Toplevel and Tk Widgets
iconbitmap method, Top-Level Window Protocols
iconify method, Top-Level Window Protocols
maxsize method, Top-Level Window Protocols
menu option, Top-Level Window Protocols, Top-Level Window Menus–Top-Level Window Menus
protocol method, Top-Level Window Protocols
quit method, Top-Level Window Protocols
title method, Top-Level Window Protocols
withdraw method, Top-Level Window Protocols
tkinter module, Configuring Widget Options and Window Titles
(see also specific widget classes; widgets)
after method, Preview: GUIs and Threads
coding alternatives, tkinter Coding Alternatives–tkinter Coding Alternatives
coding basics, tkinter Coding Basics
configuring window titles, Configuring Widget Options and Window Titles
createfilehandler tool, Time Tools, Threads, and Animation
documentation, tkinter Documentation, Where to Go from Here
extensions supported, tkinter Extensions–tkinter Extensions, Other Widgets and Options
functionality, GUI Basics–GUI Basics, Python GUI Development Options, tkinter Pragmatics
geometry managers, Geometry Managers
implementation structure, Implementation structure
programming structure, Programming structure
underscore character, Standalone Container Classes
widget classes supported, The End of the Tutorial
TkinterTreectrl third-party extension, Ideas for Improvement
toolbars
automating, GuiMaker: Automating Menus and Toolbars–BigGui: A Client Demo Program
displaying in windows, Windows with Both Menus and Toolbars–Windows with Both Menus and Toolbars
images in, Using images in toolbars, too–Using images in toolbars, too
PyDemos, PyDemos Launcher Bar (Mostly External)–PyDemos Launcher Bar (Mostly External), This Chapter’s Strategy, Multiple Windows and Status Messages
PyEdit text editor, Menus and toolbars
PyGadgets, PyGadgets Launcher Bar–PyGadgets Launcher Bar, This Chapter’s Strategy, Multiple Windows and Status Messages
Toplevel widget class
automating building windows, Wrapping Up Top-Level Window Interfaces–Wrapping Up Top-Level Window Interfaces
custom dialogs, Custom Dialogs
deiconify method, Hiding and redrawing widgets and windows
destroy method, Top-Level Window Protocols
dialogs and, Dialogs
functionality, The End of the Tutorial, Top-Level Windows–Top-Level Window Protocols
iconbitmap method, Top-Level Window Protocols
iconify method, Top-Level Window Protocols, Hiding and redrawing widgets and windows
independent windows, Independent Windows
lift method, Hiding and redrawing widgets and windows
maxsize method, Top-Level Window Protocols
menu option, Top-Level Window Protocols, Top-Level Window Menus–Top-Level Window Menus
protocol method, Top-Level Window Protocols
quit method, Top-Level Window Protocols
state method, Hiding and redrawing widgets and windows
title method, Top-Level Window Protocols
withdraw method, Top-Level Window Protocols, Hiding and redrawing widgets and windows
traceback module
CGI scripts and, Debugging CGI scripts
functionality, Exception Details
PyMailCGI program and, Error Pages, The Mail Selection List Page
transferring directories, Transferring Directories with ftplib–Refactoring with classes
transferring directory trees, Transferring Directory Trees with ftplib–Downloading Remote Trees
transferring files
to clients and servers, Transferring Files to Clients and Servers–More Than One Way to Push Bits over the Net
over the Internet, FTP: Transferring Files over the Net, Using urllib to Download Files–Using urllib to Download Files
with ftplib, Transferring Files with ftplib–Adding a User Interface
Trigger_Event function, Registration Implementation
try/finally statement, Ensuring file closure: Exception handlers and context managers
ttk extension toolkit, Python GUI Development Options, tkinter Extensions
tuple tree stacks, Optimization: Tuple Tree Stacks–Optimization: Tuple Tree Stacks
Turbo Gears tool collection, Python Internet Development Options
Twisted framework
overview, Python System Modules, Python Internet Development Options
server options, Running the select server
type command (Windows), What’s a shell command?

U

underscore (_), Standalone Container Classes
Unicode encoding
additional information, Strategies for Processing Text in Python
DBM files and, Using Shelves
email and, Unicode in Python 3.X and Email Tools
email package limitations overview, Unicode, Internationalization, and the Python 3.1 email Package
file policies, Unicode policies: File content versus file names
handling filenames, Handling Unicode Filenames in 3.X: listdir, walk, glob–Unicode policies: File content versus file names
Internationalized headers, Message header encodings: email package support–Message header encodings: email package support
mailtools utility package, Unicode issues for attachments, save files, and headers, Unicode decoding for full mail text on fetches, Unicode decoding for text part payloads and message headers
message address headers, Message address header encodings and parsing, and header creation–Message address header encodings and parsing, and header creation
message composition issues, Workaround: Message composition for non-ASCII text parts is broken–Workaround: Message composition for non-ASCII text parts is broken
message text generation issues, Workaround: Message text generation for binary attachment payloads is broken–Workaround: Message text generation for binary attachment payloads is broken
overview, Other String Concepts in Python 3.X: Unicode and bytes, Binary and Text Files, Unicode encodings for text files–Unicode encodings for text files
parser decoding requirement, Parser decoding requirement–Parser decoding requirement
printing filenames, Printing Unicode Filenames–Printing Unicode Filenames
PyEdit text editor, New Grep dialog: Threaded and Unicode-aware file tree search, Grep Unicode model, Unicode (Internationalized) text support–Unicode options and choices
PyMailCGI program and, Implementation Overview, The Send Mail Script
PyMailGUI program and, Version 3.0 Unicode support policies–Version 3.0 Unicode support policies, Ideas for Improvement
text files and, The File Object Model in Python 3.X
text payload encodings, Text payload encodings: Handling mixed type results–Text payload encodings: Using header information to decode
Text widget and, Unicode and the Text Widget–Supporting Unicode in PyEdit (ahead)
unique function, Finding Directory Differences
unittest framework, Running the Test Driver
Unix platforms
changing permissions, HTML file permission constraints
executable scripts, Parsing Command-Line Arguments
find shell command, Greps and Globs and Finds
forking support, Forking Processes
preventing zombies, Preventing zombies with signal handlers on Linux–Preventing zombies with signal handlers on Linux
programming user interfaces, Python GUI Development Options
redirecting streams, Redirecting Streams to Files and Programs
shell command limitations, Shell command limitations
urllib module
CGI script support, Using Query Strings and urllib–Using Query Strings and urllib
client-side scripting, The urllib Package Revisited–Invoking programs and escaping text
downloading files, Using urllib to Download Files–Using urllib to Download Files
PyMailCGI program and, Implementation Overview
urlretrieve interface, Other urllib Interfaces
urllib.parse module
CGI scripts and, Writing CGI Scripts in Python
functionality, Python’s Internet Library Modules
invoking programs, Invoking programs and escaping text
PyMailCGI program and, Passing State Information in URL Link Parameters
quote_plus function, Passing State Information in URL Link Parameters
URL escapes, Python HTML and URL Escape Tools–Avoiding conflicts
URL formatting, Internet addresses (URLs)
urlencode function, Passing State Information in URL Link Parameters
urllib.request module
CGI scripts and, Running Server-Side Examples
cookie support, HTTP “Cookies”, Handling cookies with the urllib.request module
downloading files, Using urllib to Download Files
functionality, Python’s Internet Library Modules, The urllib Package Revisited
HTML parsing and, HTML Parsing in Action
PyMailCGI program and, Running This Chapter’s Examples, Using the Send Mail Script Outside a Browser
screen scraping support, Python Internet Development Options
testing browsers with, Testing outside browsers with the module urllib.request–Testing outside browsers with the module urllib.request
urlopen method, Testing outside browsers with the module urllib.request
URLs
CGI script escape conventions, More on HTML and URL Escapes–Avoiding conflicts
HTML conflicts and, HTML and URL conflicts: &
minimal, Using minimal URLs, Step 1: Sharing Objects Between Pages—A New Input Form
passing parameters, Passing parameters in URLs–Passing parameters in URLs, Passing Parameters in Hardcoded URLs–Passing Parameters in Hardcoded URLs, Passing State Information in URL Link Parameters–Passing State Information in URL Link Parameters
PyMailGUI program improvements, Ideas for Improvement
query parameters, URL Query Parameters
reading mail with, Reading mail with direct URLs
syntax, Internet addresses (URLs)–Internet addresses (URLs)
user interaction
checking for missing/invalid inputs, Checking for Missing and Invalid Inputs–Checking for Missing and Invalid Inputs
form tags, More on form tags–More on form tags
passing parameters in URLs, Passing parameters in URLs–Passing parameters in URLs, Passing Parameters in Hardcoded URLs–Passing Parameters in Hardcoded URLs, Passing State Information in URL Link Parameters–Passing State Information in URL Link Parameters
response script, Response script
submission page, Submission page
uu module, Python’s Internet Library Modules

V

Value object (multiprocessing), IPC Tools: Pipes, Shared Memory, and Queues
van Rossum, Guido, Using Shelves, Other Database Options, Running the Examples, Running Examples in This Part of the Book
variables
associated, tkinter “Variables” and Form Layout Alternatives–tkinter “Variables” and Form Layout Alternatives, Checkbuttons
check buttons and, Check buttons and variables–Check buttons and variables
global, Arguments versus globals, Shared memory and globals–Shared memory and globals, Arguments versus globals
radio buttons and, Radio buttons and variables–Radio buttons and variables
scales and, Scales and variables–Scales and variables
usage recommendations, Hold onto your variables!

W

weave package, Other Extending Tools
web browsers (see browsers)
Web frameworks, Python Internet Development Options
web pages
building with CGI scripts, A First Web Page–HTML file permission constraints
generator script, Page Generator Script–Page Generator Script
sharing objects between, Step 1: Sharing Objects Between Pages—A New Input Form–Step 1: Sharing Objects Between Pages—A New Input Form
template files, Page Template File
web servers
root page examples, The Server-Side Examples Root Page
running CGI scripts, Running a Web Server–Running a Web Server, Web Server Options
running local, Running a Local Web Server–Running a Local Web Server
Web services, Python Internet Development Options
web-based interfaces
CGI scripts, CGI Basics–GUIs versus the Web
formatting reply text, Formatting Reply Text
programming suggestions, Future directions
query strings and, Using Query Strings and urllib–Using Query Strings and urllib
running web servers, Running a Web Server–Running a Web Server
shelve module support, A Web-Based Shelve Interface–Future directions
toolkit suggestions, Step 6: Adding a Web Interface
urllib module support, Using Query Strings and urllib–Using Query Strings and urllib
webbrowser module, Playing Media Files–Playing Media Files, The Python webbrowser Module–The Python webbrowser Module
websites
accessing, HTTP: Accessing Websites–HTTP: Accessing Websites
design considerations, Keeping display and logic separate
generating redirection web pages, Generating Redirection Web Pages–Page Generator Script
widget builder functions, Widget Builder Functions
widgets, Message and Entry
(see also specific widget classes)
adding multiple, Adding Multiple Widgets–Using Anchor to Position Instead of Stretch
adding via CGI scripts, Adding Common Input Devices–Adding Common Input Devices
advanced, Other Widgets and Options
after tool, Time Tools, Threads, and Animation, Simple Animation Techniques, Using widget.after events
after_cancel tool, Time Tools, Threads, and Animation
after_idle tool, Time Tools, Threads, and Animation
anchor option, Using Anchor to Position Instead of Stretch–Using Anchor to Position Instead of Stretch
attaching to frames, Attaching Widgets to Frames, Attaching Frames–Configuring at construction time
bd option, Configuring Widget Appearance
binding events, Binding Events–More on <Destroy> events and the quit and destroy methods
clipping, Widget Resizing Revisited: Clipping
config method, Configuring Widget Options and Window Titles, Configuring Widget Appearance
configuring appearance, Configuring Widget Appearance–Configuring Widget Appearance
configuring options, Configuring Widget Options and Window Titles
constructing, Making Widgets
cursor option, Configuring Widget Appearance
customizing labels, Configuring Widget Appearance
customizing with classes, Customizing Widgets with Classes–Common appearance
dialogs and, Dialogs–Other ways to be modal
expanding, Widget Resizing Revisited: Expansion
focus tool, Time Tools, Threads, and Animation
grab tool, Time Tools, Threads, and Animation
hiding and redrawing, Hiding and redrawing widgets and windows
laying out input forms, Laying Out Input Forms–Going modal again
packing layout, Layout: Packing Order and Side Attachments–Using Anchor to Position Instead of Stretch
packing without saving, Packing Widgets Without Saving Them–Packing Widgets Without Saving Them
pack_forget method, Hiding and redrawing widgets and windows
padx option, Configuring Widget Appearance
pady option, Configuring Widget Appearance
positioning in windows, Geometry Managers
PyCalc program as, Using PyCalc as a component–Using PyCalc as a component
redirecting streams to, GuiStreams: Redirecting Streams to Widgets–Using Redirection for the Packing Scripts
resizing, Widget Resizing Basics–Widget Resizing Basics, Widget Resizing Revisited: Clipping
standardizing appearance, Common appearance
standardizing behavior, Common behavior
state option, Configuring Widget Appearance
tkinter widget classes, The End of the Tutorial
top-level windows, Top-Level Windows–Top-Level Window Protocols
update tool, Time Tools, Threads, and Animation
update_idletasks tool, Time Tools, Threads, and Animation
wait_variable tool, Time Tools, Threads, and Animation
wait_visibility tool, Time Tools, Threads, and Animation
wait_window tool, Time Tools, Threads, and Animation
wildcard characters, The glob module
windows
automating building, Wrapping Up Top-Level Window Interfaces–Wrapping Up Top-Level Window Interfaces
configuring titles, Configuring Widget Options and Window Titles
hiding and redrawing, Hiding and redrawing widgets and windows
independent, Independent Windows–Independent Windows
menus and toolbars, Windows with Both Menus and Toolbars–Automating menu construction
popping up on demand, Popping Up GUI Windows on Demand–Popping Up GUI Windows on Demand
positioning widgets in, Geometry Managers
PyEdit text editor, Multiple windows–Multiple windows
PyMailGUI program support, Multiple Windows and Status Messages–Multiple Windows and Status Messages
Windows environment
avoiding DOS consoles, Avoiding DOS consoles on Windows
Component Object Model, Python Internet Development Options
directory paths, The Module Search Path
Distributed Component Object Model, Python Internet Development Options
programming user interfaces, Python GUI Development Options, Python GUI Development Options
redirecting streams, Redirecting Streams to Files and Programs
shell command limitations, Shell command limitations
standard streams and, Standard Streams
tkinter support, Running the Examples
with statement, Ensuring file closure: Exception handlers and context managers
wrapping
C environment calls, Wrapping C Environment Calls–Wrapping C Environment Calls with SWIG
C++ classes with SWIG, Wrapping C++ Classes with SWIG–Exploring the wrappers interactively
descriptors in file objects, Wrapping descriptors in file objects, Wrapping pipe descriptors in file objects
writing
CGI scripts, Writing CGI Scripts in Python–Writing CGI Scripts in Python
custom language parsers, Custom Language Parsers–Parsers Versus Python
files, Writing
wxPython system, Python GUI Development Options

X

X11 interface, Python GUI Development Options
xdrlib module, Python’s Internet Library Modules
xml package
development options, Python Internet Development Options
functionality, XML and HTML Parsing
XML parsing
additional resources, Other XML topics
DOM parsers, XML and HTML Parsing, DOM parsing
ElementTree support, XML and HTML Parsing, ElementTree parsing
functionality, XML Parsing in Action
overview, Python Internet Development Options, XML and HTML Parsing
regular expressions and, Regular expression parsing
SAX parsers, XML and HTML Parsing, SAX parsing
third-party tools, Other XML topics
XML-RPC
functionality, Python Internet Development Options
integration considerations, Other Integration Topics
persistence options, Persistence Options in Python
pickled objects and, Using Object Pickling
xml.etree package, ElementTree parsing
xmlrpc package, Other Client-Side Scripting Options, XML and HTML Parsing

Y

YAPPS parser generator, Advanced Language Tools

Z

zips, summing with, Summing with zips and comprehensions
ZODB system
functionality, Other Database Options, The ZODB Object-Oriented Database–The ZODB Object-Oriented Database
pickled objects and, Pickling in Action
usage considerations, The Mostly Missing ZODB Tutorial–The Mostly Missing ZODB Tutorial
zombie processes, Killing the zombies: Don’t fear the reaper!–Preventing zombies with signal handlers on Linux
Zope toolkit, Python Internet Development Options, Keeping display and logic separate
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset