Programming Python by Mark Lutz -- Read -- Imperial Library of Trantor

Python System Modules Module Documentation Sources Paging Documentation Strings A Custom Paging Script String Method Basics Other String Concepts in Python 3.X: Unicode and bytes File Operation Basics Using Programs in Two Ways Python Library Manuals Commercially Published References

Introducing the sys Module

Platforms and Versions The Module Search Path The Loaded Modules Table Exception Details Other sys Module Exports

Introducing the os Module

Tools in the os Module Administrative Tools Portability Constants Common os.path Tools Running Shell Commands from Scripts

What’s a shell command? Running shell commands Communicating with shell commands The subprocess module alternative Shell command limitations

Other os Module Exports

3. Script Execution Context

“I’d Like to Have an Argument, Please” Current Working Directory

CWD, Files, and Import Paths CWD and Command Lines

Command-Line Arguments

Parsing Command-Line Arguments

Shell Environment Variables

Fetching Shell Variables Changing Shell Variables Shell Variable Fine Points: Parents, putenv, and getenv

Standard Streams

Redirecting Streams to Files and Programs

Chaining programs with pipes Coding alternatives for adders and sorters

Redirected Streams and User Interaction Redirecting Streams to Python Objects The io.StringIO and io.BytesIO Utility Classes Capturing the stderr Stream Redirection Syntax in Print Calls Other Redirection Options: os.popen and subprocess Revisited

Redirecting input or output with os.popen Redirecting input and output with subprocess

4. File and Directory Tools

“Erase Your Hard Drive in Five Easy Steps!” File Tools

The File Object Model in Python 3.X Using Built-in File Objects

Output files

Opening Writing Closing

Ensuring file closure: Exception handlers and context managers Input files Reading lines with file iterators Other open options

Binary and Text Files

Unicode encodings for text files End-of-line translations for text files Parsing packed binary data with the struct module Random access files

Lower-Level File Tools in the os Module

Using os.open files os.open mode flags Wrapping descriptors in file objects Other os module file tools

File Scanners

File filters

Directory Tools

Walking One Directory

Running shell listing commands with os.popen The glob module The os.listdir call Splitting and joining listing results

Walking Directory Trees

The os.walk visitor Recursive os.listdir traversals

Handling Unicode Filenames in 3.X: listdir, walk, glob

Unicode policies: File content versus file names

5. Parallel System Tools

“Telling the Monkeys What to Do” Forking Processes

The fork/exec Combination

os.exec call formats Spawned child program

Threads

The _thread Module

Basic usage Other ways to code threads with _thread Running multiple threads Synchronizing access to shared objects and names Waiting for spawned thread exits Coding alternatives: busy loops, arguments, and context managers

The threading Module

Other ways to code threads with threading Synchronizing access to shared objects and names revisited

The queue Module

Arguments versus globals Program exit with child threads Running the script

Preview: GUIs and Threads More on the Global Interpreter Lock

The thread switch interval Atomic operations C API thread considerations A process-based alternative: multiprocessing (ahead)

Program Exits

sys Module Exits os Module Exits Shell Command Exit Status Codes

Exit status with os.system and os.popen Output stream buffering: A first look Exit status with subprocess

Process Exit Status and Shared State Thread Exits and Shared State

Interprocess Communication

Anonymous Pipes

Anonymous pipe basics Wrapping pipe descriptors in file objects Anonymous pipes and threads Bidirectional IPC with anonymous pipes Output stream buffering revisited: Deadlocks and flushes

Named Pipes (Fifos)

Named pipe basics Named pipe use cases

Sockets: A First Look

Socket basics Sockets and independent programs Socket use cases

Signals

The multiprocessing Module

Why multiprocessing? The Basics: Processes and Locks

Implementation and usage rules

IPC Tools: Pipes, Shared Memory, and Queues

multiprocessing pipes Shared memory and globals Queues and subclassing

Starting Independent Programs And Much More

And a little less…

Why multiprocessing? The Conclusion

Other Ways to Start Programs

The os.spawn Calls The os.startfile call on Windows

Using the DOS start command Using start in Python scripts The os.startfile call

A Portable Program-Launch Framework Other System Tools Coverage

6. Complete System Programs

“The Greps of Wrath” A Quick Game of “Find the Biggest Python File”

Scanning the Standard Library Directory Scanning the Standard Library Tree Scanning the Module Search Path Scanning the Entire Machine Printing Unicode Filenames

Splitting and Joining Files

Splitting Files Portably Joining Files Portably Usage Variations

Generating Redirection Web Pages

Page Template File Page Generator Script

A Regression Test Script

Running the Test Driver

Copying Directory Trees Comparing Directory Trees

Finding Directory Differences Finding Tree Differences Running the Script Verifying Backups Reporting Differences and Other Ideas

Searching Directory Trees

Greps and Globs and Finds Rolling Your Own find Module

The fnmatch module

Cleaning Up Bytecode Files A Python Tree Searcher

Visitor: Walking Directories “++”

Editing Files in Directory Trees (Visitor) Global Replacements in Directory Trees (Visitor) Counting Source Code Lines (Visitor) Recoding Copies with Classes (Visitor) Other Visitor Examples (External)

Playing Media Files

The Python webbrowser Module The Python mimetypes Module

Using mimetypes guesses for SearchVisitor

Running the Script

Automated Program Launchers (External)

III. GUI Programming

7. Graphical User Interfaces

“Here’s Looking at You, Kid”

GUI Programming Topics Running the Examples

Python GUI Development Options tkinter Overview

tkinter Pragmatics tkinter Documentation tkinter Extensions tkinter Structure

Implementation structure Programming structure

Climbing the GUI Learning Curve

“Hello World” in Four Lines (or Less) tkinter Coding Basics Making Widgets Geometry Managers Running GUI Programs

Avoiding DOS consoles on Windows

tkinter Coding Alternatives

Widget Resizing Basics Configuring Widget Options and Window Titles One More for Old Times’ Sake Packing Widgets Without Saving Them

Adding Buttons and Callbacks

Widget Resizing Revisited: Expansion

Adding User-Defined Callback Handlers

Lambda Callback Handlers Deferring Calls with Lambdas and Object References Callback Scope Issues

Arguments versus globals Passing in enclosing scope values with default arguments Passing in enclosing scope values with automatic references But you must still sometimes use defaults instead of enclosing scopes

Bound Method Callback Handlers Callable Class Object Callback Handlers Other tkinter Callback Protocols Binding Events

Adding Multiple Widgets

Widget Resizing Revisited: Clipping Attaching Widgets to Frames Layout: Packing Order and Side Attachments The Packer’s Expand and Fill Revisited Using Anchor to Position Instead of Stretch

Customizing Widgets with Classes

Standardizing Behavior and Appearance

Common behavior Common appearance

Reusable GUI Components with Classes

Attaching Class Components Extending Class Components Standalone Container Classes

The End of the Tutorial Python/tkinter for Tcl/Tk Converts

8. A tkinter Tour, Part 1

“Widgets and Gadgets and GUIs, Oh My!”

This Chapter’s Topics

Configuring Widget Appearance Top-Level Windows

Toplevel and Tk Widgets Top-Level Window Protocols

Dialogs

Standard (Common) Dialogs

A “smart” and reusable Quit button A dialog demo launcher bar Printing dialog results and passing callback data with lambdas Letting users select colors on the fly Other standard dialog calls

The Old-Style Dialog Module Custom Dialogs

Making custom dialogs modal Other ways to be modal

Binding Events

Other bind Events

More on <Destroy> events and the quit and destroy methods

Message and Entry

Message Entry

Programming Entry widgets

Laying Out Input Forms

Going modal again

tkinter “Variables” and Form Layout Alternatives

Checkbutton, Radiobutton, and Scale

Checkbuttons

Check buttons and variables

Radio Buttons

Radio buttons and variables Radio buttons without variables Hold onto your variables!

Scales (Sliders)

Scales and variables

Running GUI Code Three Ways

Attaching Frames

Importing by name string Configuring at construction time

Independent Windows Running Programs

Launching GUIs as programs other ways: multiprocessing Cross-program communication Coding for reusability

Images

Fun with Buttons and Pictures

Viewing and Processing Images with PIL

PIL Basics Displaying Other Image Types with PIL

Displaying all images in a directory

Creating Image Thumbnails with PIL

Performance: Saving thumbnail files Layout options: Gridding Layout options: Fixed-size buttons Scrolling and canvases (ahead)

9. A tkinter Tour, Part 2

“On Today’s Menu: Spam, Spam, and Spam” Menus

Top-Level Window Menus Frame- and Menubutton-Based Menus

Using Menubuttons and Optionmenus

Windows with Both Menus and Toolbars

Using images in toolbars, too Automating menu construction

Listboxes and Scrollbars

Programming Listboxes Programming Scroll Bars Packing Scroll Bars

Text

Programming the Text Widget

Text is a Python string String positions

Text indexes Text marks Text tags

Adding Text-Editing Operations

Using the clipboard Composition versus inheritance It’s called “Simple” for a reason: PyEdit (ahead)

Unicode and the Text Widget

String types in the Text widget Unicode text in strings Unicode text in files Unicode and the Text widget The problem with treating text as bytes Other binary mode considerations Supporting Unicode in PyEdit (ahead)

Advanced Text and Tag Operations

Canvas

Basic Canvas Operations Programming the Canvas Widget

Coordinates Object construction Object identifiers and operations Canvas object tags

Scrolling Canvases Scrollable Canvases and Image Thumbnails

Scrolling images too: PyPhoto (ahead)

Using Canvas Events

Binding events on specific items

Grids

Why Grids? Grid Basics: Input Forms Revisited Comparing grid and pack Combining grid and pack Making Gridded Widgets Expandable

Resizing in grids Spanning columns and rows

Laying Out Larger Tables with grid

Time Tools, Threads, and Animation

Using Threads with tkinter GUIs Using the after Method

Hiding and redrawing widgets and windows

Simple Animation Techniques

Using time.sleep loops Using widget.after events Using multiple time.sleep loop threads