book

Learning Python

by Mark Lutz, David Ascher

April 1999

Beginner

384 pages

11h 15m

English

O'Reilly Media, Inc.

Read now

Unlock full access

About This BookThis Book’s ScopeThis Book’s StylePart IPart IIPart IIIPrerequisitesBook Updates
Mark Also Says:David Also Says:
Why Python?An Executive SummaryIt’s object-orientedIt’s freeIt’s portableIt’s powerfulIt’s mixableIt’s easy to useIt’s easy to learnPython on the JobSystem utilitiesGUIsComponent integrationRapid prototypingInternet scriptingNumeric programmingDatabase programmingAnd more: Image processing, AI, distributed objects, etc.Python in Commercial ProductsPython Versus Similar Tools
The Interactive Command LineRunning Module FilesRunning Unix-Style ScriptsEmbedded Code and ObjectsPlatform-Specific Startup MethodsWhat You Type and Where You Type It
A First Look at Namespace Inspection

Environment VariablesAn Example Startup ScriptA GUI Test SessionInstallation Overview
Python Program Structure
Standard Numeric TypesBuilt-in Tools and ExtensionsPython Expression OperatorsMixed operators: Operators bind tighter lower in the tableParentheses group subexpressionsMixed types: Converted up just as in CPreview: operator overloadingNumbers in ActionBasic operationsB itwise operationsL ong integersComplex numbersOther numeric tools
Strings in ActionBasic operationsIndexing and slicingC hanging and formattingCommon string toolsString constant variationsGeneric Type ConceptsTypes share operation sets by categoriesMutable types can be changed in place
Lists in ActionBasic operationsIn dexing and slicingChanging lists in place
Dictionaries in ActionBasic operationsChanging dictionariesA marginally more real exampleDictionary Usage Notes
Why Lists and Tuples?
Files in ActionRelated Python Tools
Type Categories RevisitedGeneralityShared ReferencesComparisons, Equality, and TruthPython’s Type Hierarchies
Assignment Creates References, Not CopiesSolutionsRepetition Adds One-Level DeepSolutionsCyclic Data Structures Can’t Be PrintedSolutionsImmutable Types Can’t Be Changed in PlaceSolutions
AssignmentVariable Name Rules
The Python “Hello World” Program
General FormatExamplesPython Syntax RulesB lock delimitersS tatement delimitersA few special casesTruth Tests Revisited
General FormatExamplesbreak, continue, pass, and the Loop elseGeneral loop formatExamples
General FormatExamplesrange and Counter LoopsExamples
Why Use Functions?
General FormDefinitions and CallsExample: Intersecting SequencesDefinitionCalls
Name Resolution: The LGB RuleExampleThe global Statement
More on returnSpecial Argument-Matching ModesA first exampleA second example: Arbitrary-argument set functionsThe gritty details
lambda ExpressionsThe apply Built-inThe map Built-inPython “Procedures”Function Design ConceptsFunctions Are Objects: Indirect Calls
Local Names Are Detected StaticallySolutionNested Functions Aren’t Nested ScopesSolutionUsing Defaults to Save ReferencesDefaults and Mutable ObjectsSolution
Why Use Modules?
DefinitionUsage
Name Qualification
Imports Happen Only Onceimport and from Are Assignments
General FormExample
Module Compilation ModelData Hiding Is a ConventionMixed Modes: __name__ and __main__Changing the Module Search PathModule Packages (New in 1.5)Module Design ConceptsModules Are Objects: Metaprograms
Importing Modules by Name StringSolutionfrom Copies Names but Doesn’t LinkSolutionStatement Order Matters in Top-Level CodeSolutionRecursive “from” Imports May Not WorkSolutionsreload May Not Impact from ImportsSolutionreload Isn’t Applied TransitivelySolution
Why Use Classes?
Classes Generate Multiple Instance ObjectsClass objects provide default behaviorInstance objects are generated from classesAn exampleClasses Are Specialized by I nheritanceAn exampleClasses Can Intercept Python OperatorsAn example
General FormExample
Example
Attribute Tree ConstructionSpecializing Inherited Methods
Common Operator Overloading MethodsExamples__getitem__ intercepts all index references__getattr__ catches undefined attribute references_ _repr__ returns a string representation
Unqualified Names: Global Unless AssignedQualified Names: Object NamespacesN amespace Dictionaries
Python and OOPOOP and Inheritance: “is-a”OOP and Composition: “has-a”OOP and DelegationExtending Built-in Object TypesMultiple InheritanceClasses Are Objects: Generic Object FactoriesMethods Are Objects: Bound or Unbound
Private Attributes (New in 1.5)Documentation StringsC lasses Versus Modules
Changing Class Attributes Can Have Side EffectsSolutionMultiple Inheritance: Order MattersSolutionClass Function Attributes Are SpecialSolutionMethods, Classes, and Nested ScopesSolution
Why Use Exceptions?
try/except/elsetry/finallyraiseFirst ExamplesDefault behavior: Error messagesCatching built-in exceptionsRaising and catching user-defined exceptions
Exceptions Aren’t Always a Bad ThingSearches Sometimes Signal Success by raiseOuter try Statements Can Debug Code
try Statement ClausesCatching 1-of-N ExceptionsExceptions Nest at Runtimefinally Clauses Run “On the Way Out”
Passing Optional DataThe assert StatementClass ExceptionsGeneral raise formsExample
Exceptions Match by Identity, Not EqualityCatching Too Much?SolutionCatching Too Little?Solution
Aside: The sys Module
Conversions, Numbers, and ComparisonsAttribute ManipulationExecuting Programs
Basic String Operations: The string ModuleAdvanced String Operations: The re ModuleRegular expressionsA real regular expression problemGeneric Operating-System Interfaces: The os ModuleThe os and os.path modulesCopying Files and Directories: The shutil ModuleInternet-Related ModulesThe Common Gateway Interface: The cgi moduleManipulating URLs: the urllib and urlparse modulesSpecific Internet protocolsProcessing Internet dataDealing with Binary Data: The struct ModuleDebugging, Timing, Profiling
Data Structure ManipulationsMaking Copies InlineMaking Copies: The copy ModuleSorting and RandomizingRandomizing: The random ModuleMaking New Data StructuresMaking New Lists and Dictionaries: The UserList and UserDict Modules
Doing Something to Each Line in a FileChoosing chunk sizesDoing Something to a Set of Files Specified on the Command LineThe f ileinput ModuleFilenames and DirectoriesMatching Sets of Files: The glob ModuleUsing Temporary FilesMore on Scanning Text Files
Calling Other Programs
Downloading a Web Page ProgrammaticallyChecking the Validity of Links and Mirroring Web Sites: webchecker.py and FriendsChecking Mail
Compounding Your InterestAn Automated Dial-Out ScriptAn Interactive Rolodex
An Automated Complaint System
JPython Gives Python Programmers Access to Java LibrariesJPython as a Java Scripting LanguageA Real JPython/Swing Application: grapher.py
Python Imaging Library (PIL)Numeric Python (NumPy)SWIGPython MegaWidgets (Pmw)ILU and Fnorb
The Python Language Web Site
The Standard Python DistributionGifts from GuidoOfferings from Commercial VendorsScriptics Corporation’s Tcl/Tk toolkitsDigital Creation’s free releasesPythonwareOther Modules and PackagesEmacs Support
The Standard Python Documentation SetThe FAQOther Published BooksOther Sources of Documentation
comp.lang.python/python-listcomp.lang.python.announce/python-list-announcepython-help@python.orgThe SIGsJPython-interest
UnixUnix-Specific ExtensionsStandard distributionSGI-specific extensionsSunOS-specific extensionsOther Unix resources
Chapter 1

Overview

Learning Python is an introduction to the increasingly popular Python programming language. Python is an interpreted, interactive, object-oriented scripting language. Python is growing in popularity because:

It is available on all important platforms: Windows NT, Windows 95, Windows 98, Linux, all major UNIX platforms, MacOS, and even the BeOS.
It is open-source software, copyrighted but freely available for use, even in commercial applications.
Its clean object-oriented interface makes it a valuable prototyping tool for C++ programmers.
It works well with all popular windowing toolkits, including MFC, Tk, Mac, X11, and Motif. Learning Python is written by Mark Lutz, author of Programming Python and Python Pocket Reference; and David Ascher, a vision scientist and Python user. This book starts with a thorough introduction to the elements of Python: types, operators, statements, classes, functions, modules, and exceptions. By reading the first part of the book, the reader will be able to understand and construct programs in the Python language. In the second part of the book, the authors present more advanced information, demonstrating how Python performs common tasks and presenting real applications and the libraries available for those applications. All the examples use the Python interpreter, so the reader can type them in and get instant feedback. Each chapter ends with a series of exercises. Solutions to the exercises are in an appendix.