book

Learning Python, 4th Edition

Name: Learning Python, 4th Edition
Author: Mark Lutz
ISBN: 9780596158064

by Mark Lutz

October 2009

Beginner

1214 pages

37h 22m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Dedication
A Note Regarding Supplemental Files
Preface
About This Fourth EditionCoverage for Both 3.0 and 2.6New ChaptersChanges to Existing MaterialSpecific Language Extensions in 2.6 and 3.0Specific Language Removals in 3.0About The Third EditionThe Third Edition’s Python Language ChangesThe Third Edition’s Python Training ChangesThe Third Edition’s Structural ChangesThe Third Edition’s Scope ChangesAbout This BookThis Book’s PrerequisitesThis Book’s Scope and Other BooksThis Book’s Style and StructureBook UpdatesAbout the Programs in This BookUsing Code ExamplesFont ConventionsSafari® Books OnlineHow to Contact UsAcknowledgments
I. Getting Started
1. A Python Q&A Session
Why Do People Use Python?Software QualityDeveloper ProductivityIs Python a “Scripting Language”?OK, but What’s the Downside?Who Uses Python Today?What Can I Do with Python?Systems ProgrammingGUIsInternet ScriptingComponent IntegrationDatabase ProgrammingRapid PrototypingNumeric and Scientific ProgrammingGaming, Images, Serial Ports, XML, Robots, and MoreHow Is Python Supported?What Are Python’s Technical Strengths?It’s Object-OrientedIt’s FreeIt’s PortableIt’s PowerfulIt’s MixableIt’s Easy to UseIt’s Easy to LearnIt’s Named After Monty PythonHow Does Python Stack Up to Language X?Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
2. How Python Runs Programs
Introducing the Python InterpreterProgram ExecutionThe Programmer’s ViewPython’s ViewByte code compilationThe Python Virtual Machine (PVM)Performance implicationsDevelopment implicationsExecution Model VariationsPython Implementation AlternativesCPythonJythonIronPythonExecution Optimization ToolsThe Psyco just-in-time compilerThe Shedskin C++ translatorFrozen BinariesOther Execution OptionsFuture Possibilities?Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
3. How You Run Programs
The Interactive PromptRunning Code InteractivelyWhy the Interactive Prompt?ExperimentingTestingUsing the Interactive PromptEntering multiline statementsSystem Command Lines and FilesA First ScriptRunning Files with Command LinesUsing Command Lines and FilesUnix Executable Scripts (#!)Clicking File IconsClicking Icons on WindowsThe input TrickOther Icon-Click LimitationsModule Imports and ReloadsThe Grander Module Story: AttributesModules and namespacesimport and reload Usage NotesUsing exec to Run Module FilesThe IDLE User InterfaceIDLE BasicsUsing IDLEAdvanced IDLE ToolsOther IDEsOther Launch OptionsEmbedding CallsFrozen Binary ExecutablesText Editor Launch OptionsStill Other Launch OptionsFuture Possibilities?Which Option Should I Use?Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: AnswersTest Your Knowledge: Part I Exercises
II. Types and Operations
4. Introducing Python Object Types
Why Use Built-in Types?Python’s Core Data TypesNumbersStringsSequence OperationsImmutabilityType-Specific MethodsGetting HelpOther Ways to Code StringsPattern MatchingListsSequence OperationsType-Specific OperationsBounds CheckingNestingComprehensionsDictionariesMapping OperationsNesting RevisitedSorting Keys: for LoopsIteration and OptimizationMissing Keys: if TestsTuplesWhy Tuples?FilesOther File-Like ToolsOther Core TypesHow to Break Your Code’s FlexibilityUser-Defined ClassesAnd Everything ElseChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
5. Numeric Types
Numeric Type BasicsNumeric LiteralsBuilt-in Numeric ToolsPython Expression OperatorsMixed operators follow operator precedenceParentheses group subexpressionsMixed types are converted upPreview: Operator overloading and polymorphismNumbers in ActionVariables and Basic ExpressionsNumeric Display FormatsComparisons: Normal and ChainedDivision: Classic, Floor, and TrueSupporting either PythonFloor versus truncationWhy does truncation matter?Integer PrecisionComplex NumbersHexadecimal, Octal, and Binary NotationBitwise OperationsOther Built-in Numeric ToolsOther Numeric TypesDecimal TypeThe basicsSetting precision globallyDecimal context managerFraction TypeThe basicsNumeric accuracyConversions and mixed typesSetsSet basics in Python 2.6Set literals in Python 3.0Immutable constraints and frozen setsSet comprehensions in Python 3.0Why sets?BooleansNumeric ExtensionsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers

6. The Dynamic Typing Interlude
The Case of the Missing Declaration StatementsVariables, Objects, and ReferencesTypes Live with Objects, Not VariablesObjects Are Garbage-CollectedShared ReferencesShared References and In-Place ChangesShared References and EqualityDynamic Typing Is EverywhereChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
7. Strings
String LiteralsSingle- and Double-Quoted Strings Are the SameEscape Sequences Represent Special BytesRaw Strings Suppress EscapesTriple Quotes Code Multiline Block StringsStrings in ActionBasic OperationsIndexing and SlicingExtended slicing: the third limit and slice objectsString Conversion ToolsCharacter code conversionsChanging StringsString MethodsString Method Examples: Changing StringsString Method Examples: Parsing TextOther Common String Methods in ActionThe Original string Module (Gone in 3.0)String Formatting ExpressionsAdvanced String Formatting ExpressionsDictionary-Based String Formatting ExpressionsString Formatting Method CallsThe BasicsAdding Keys, Attributes, and OffsetsAdding Specific FormattingComparison to the % Formatting ExpressionWhy the New Format Method?Extra featuresExplicit value referencesMethod names and general argumentsPossible future deprecation?General Type CategoriesTypes Share Operation Sets by CategoriesMutable Types Can Be Changed In-PlaceChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
8. Lists and Dictionaries
ListsLists in ActionBasic List OperationsList Iteration and ComprehensionsIndexing, Slicing, and MatrixesChanging Lists In-PlaceIndex and slice assignmentsList method callsOther common list operationsDictionariesDictionaries in ActionBasic Dictionary OperationsChanging Dictionaries In-PlaceMore Dictionary MethodsA Languages TableDictionary Usage NotesUsing dictionaries to simulate flexible listsUsing dictionaries for sparse data structuresAvoiding missing-key errorsUsing dictionaries as “records”Other Ways to Make DictionariesDictionary Changes in Python 3.0Dictionary comprehensionsDictionary viewsDictionary views and setsSorting dictionary keysDictionary magnitude comparisons no longer workThe has_key method is dead: long live in!Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
9. Tuples, Files, and Everything Else
TuplesTuples in ActionTuple syntax peculiarities: Commas and parenthesesConversions, methods, and immutabilityWhy Lists and Tuples?FilesOpening FilesUsing FilesFiles in ActionText and binary files in Python 3.0Storing and parsing Python objects in filesStoring native Python objects with pickleStoring and parsing packed binary data in filesFile context managersOther File ToolsType Categories RevisitedObject FlexibilityReferences Versus CopiesComparisons, Equality, and TruthPython 3.0 Dictionary ComparisonsThe Meaning of True and False in PythonThe None objectThe bool typePython’s Type HierarchiesType ObjectsOther Types in PythonBuilt-in Type GotchasAssignment Creates References, Not CopiesRepetition Adds One Level DeepBeware of Cyclic Data StructuresImmutable Types Can’t Be Changed In-PlaceChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: AnswersTest Your Knowledge: Part II Exercises
III. Statements and Syntax
10. Introducing Python Statements
Python Program Structure RevisitedPython’s StatementsA Tale of Two ifsWhat Python AddsWhat Python RemovesParentheses are optionalEnd of line is end of statementEnd of indentation is end of blockWhy Indentation Syntax?A Few Special CasesStatement rule special casesBlock rule special caseA Quick Example: Interactive LoopsA Simple Interactive LoopDoing Math on User InputsHandling Errors by Testing InputsHandling Errors with try StatementsNesting Code Three Levels DeepChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
11. Assignments, Expressions, and Prints
Assignment StatementsAssignment Statement FormsSequence AssignmentsAdvanced sequence assignment patternsExtended Sequence Unpacking in Python 3.0Extended unpacking in actionBoundary casesA useful convenienceApplication to for loopsMultiple-Target AssignmentsMultiple-target assignment and shared referencesAugmented AssignmentsAugmented assignment and shared referencesVariable Name RulesNaming conventionsNames have no type, but objects doExpression StatementsExpression Statements and In-Place ChangesPrint OperationsThe Python 3.0 print FunctionCall formatThe 3.0 print function in actionThe Python 2.6 print StatementStatement formsThe 2.6 print statement in actionPrint Stream RedirectionThe Python “hello world” programManual stream redirectionAutomatic stream redirectionVersion-Neutral PrintingChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
12. if Tests and Syntax Rules
if StatementsGeneral FormatBasic ExamplesMultiway BranchingPython Syntax RulesBlock Delimiters: Indentation RulesAvoid mixing tabs and spaces: New error checking in 3.0Statement Delimiters: Lines and ContinuationsA Few Special CasesTruth TestsThe if/else Ternary ExpressionChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
13. while and for Loops
while LoopsGeneral FormatExamplesbreak, continue, pass, and the Loop elseGeneral Loop FormatpasscontinuebreakLoop elseMore on the loop elsefor LoopsGeneral FormatExamplesBasic usageOther data typesTuple assignment in for loopsPython 3.0 extended sequence assignment in for loopsNested for loopsLoop Coding TechniquesCounter Loops: while and rangeNonexhaustive Traversals: range and SlicesChanging Lists: rangeParallel Traversals: zip and mapmap equivalence in Python 2.6Dictionary construction with zipGenerating Both Offsets and Items: enumerateChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
14. Iterations and Comprehensions, Part 1
Iterators: A First LookThe Iteration Protocol: File IteratorsManual Iteration: iter and nextOther Built-in Type IteratorsList Comprehensions: A First LookList Comprehension BasicsUsing List Comprehensions on FilesExtended List Comprehension SyntaxOther Iteration ContextsNew Iterables in Python 3.0The range IteratorThe map, zip, and filter IteratorsMultiple Versus Single IteratorsDictionary View IteratorsOther Iterator TopicsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
15. The Documentation Interlude
Python Documentation Sources# CommentsThe dir FunctionDocstrings: __doc__User-defined docstringsDocstring standardsBuilt-in docstringsPyDoc: The help FunctionPyDoc: HTML ReportsThe Standard Manual SetWeb ResourcesPublished BooksCommon Coding GotchasChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: AnswersTest Your Knowledge: Part III Exercises
IV. Functions
16. Function Basics
Why Use Functions?Coding Functionsdef Statementsdef Executes at RuntimeA First Example: Definitions and CallsDefinitionCallsPolymorphism in PythonA Second Example: Intersecting SequencesDefinitionCallsPolymorphism RevisitedLocal VariablesChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
17. Scopes
Python Scope BasicsScope RulesName Resolution: The LEGB RuleScope ExampleThe Built-in ScopeThe global StatementMinimize Global VariablesMinimize Cross-File ChangesOther Ways to Access GlobalsScopes and Nested FunctionsNested Scope DetailsNested Scope ExamplesFactory functionsRetaining enclosing scopes’ state with defaultsNested scopes and lambdasScopes versus defaults with loop variablesArbitrary scope nestingThe nonlocal Statementnonlocal Basicsnonlocal in ActionUsing nonlocal for changesBoundary casesWhy nonlocal?Shared state with globalsState with classes (preview)State with function attributesChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
18. Arguments
Argument-Passing BasicsArguments and Shared ReferencesAvoiding Mutable Argument ChangesSimulating Output ParametersSpecial Argument-Matching ModesThe BasicsMatching SyntaxThe Gritty DetailsKeyword and Default ExamplesKeywordsDefaultsCombining keywords and defaultsArbitrary Arguments ExamplesCollecting argumentsUnpacking argumentsApplying functions genericallyThe defunct apply built-in (Python 2.6)Python 3.0 Keyword-Only ArgumentsOrdering rulesWhy keyword-only arguments?The min Wakeup Call!Full CreditBonus PointsThe Punch Line...Generalized Set FunctionsEmulating the Python 3.0 print FunctionUsing Keyword-Only ArgumentsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
19. Advanced Function Topics
Function Design ConceptsRecursive FunctionsSummation with RecursionCoding AlternativesLoop Statements Versus RecursionHandling Arbitrary StructuresFunction Objects: Attributes and AnnotationsIndirect Function CallsFunction IntrospectionFunction AttributesFunction Annotations in 3.0Anonymous Functions: lambdalambda BasicsWhy Use lambda?How (Not) to Obfuscate Your Python CodeNested lambdas and ScopesMapping Functions over Sequences: mapFunctional Programming Tools: filter and reduceChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
20. Iterations and Comprehensions, Part 2
List Comprehensions Revisited: Functional ToolsList Comprehensions Versus mapAdding Tests and Nested Loops: filterList Comprehensions and MatrixesComprehending List ComprehensionsIterators Revisited: GeneratorsGenerator Functions: yield Versus returnState suspensionIteration protocol integrationGenerator functions in actionExtended generator function protocol: send versus nextGenerator Expressions: Iterators Meet ComprehensionsGenerator Functions Versus Generator ExpressionsGenerators Are Single-Iterator ObjectsEmulating zip and map with Iteration ToolsCoding your own map(func, ...)Coding your own zip(...) and map(None, ...)Value Generation in Built-in Types and Classes3.0 Comprehension Syntax SummaryComprehending Set and Dictionary ComprehensionsExtended Comprehension Syntax for Sets and DictionariesTiming Iteration AlternativesTiming ModuleTiming ScriptTiming ResultsTiming Module AlternativesUsing keyword-only arguments in 3.0Other SuggestionsFunction GotchasLocal Names Are Detected StaticallyDefaults and Mutable ObjectsFunctions Without returnsEnclosing Scope Loop VariablesChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: AnswersTest Your Knowledge: Part IV Exercises
V. Modules
21. Modules: The Big Picture
Why Use Modules?Python Program ArchitectureHow to Structure a ProgramImports and AttributesStandard Library ModulesHow Imports Work1. Find It2. Compile It (Maybe)3. Run ItThe Module Search PathConfiguring the Search PathSearch Path VariationsThe sys.path ListModule File SelectionAdvanced Module Selection ConceptsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
22. Module Coding Basics
Module CreationModule UsageThe import StatementThe from StatementThe from * StatementImports Happen Only Onceimport and from Are AssignmentsCross-File Name Changesimport and from EquivalencePotential Pitfalls of the from StatementWhen import is requiredModule NamespacesFiles Generate NamespacesAttribute Name QualificationImports Versus ScopesNamespace NestingReloading Modulesreload Basicsreload ExampleChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
23. Module Packages
Package Import BasicsPackages and Search Path SettingsPackage __init__.py FilesPackage Import Examplefrom Versus import with PackagesWhy Use Package Imports?A Tale of Three SystemsPackage Relative ImportsChanges in Python 3.0Relative Import BasicsWhy Relative Imports?The relative imports solution in 3.0Relative imports versus absolute package pathsThe Scope of Relative ImportsModule Lookup Rules SummaryRelative Imports in ActionImports outside packagesImports within packagesImports are still relative to the CWDSelecting modules with relative and absolute importsImports are still relative to the CWD (again)Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
24. Advanced Module Topics
Data Hiding in ModulesMinimizing from * Damage: _X and __all__Enabling Future Language FeaturesMixed Usage Modes: __name__ and __main__Unit Tests with __name__Using Command-Line Arguments with __name__Changing the Module Search PathThe as Extension for import and fromModules Are Objects: MetaprogramsImporting Modules by Name StringTransitive Module ReloadsModule Design ConceptsModule GotchasStatement Order Matters in Top-Level Codefrom Copies Names but Doesn’t Linkfrom * Can Obscure the Meaning of Variablesreload May Not Impact from Importsreload, from, and Interactive TestingRecursive from Imports May Not WorkChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: AnswersTest Your Knowledge: Part V Exercises
VI. Classes and OOP
25. OOP: The Big Picture
Why Use Classes?OOP from 30,000 FeetAttribute Inheritance SearchClasses and InstancesClass Method CallsCoding Class TreesOOP Is About Code ReuseChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
26. Class Coding Basics
Classes Generate Multiple Instance ObjectsClass Objects Provide Default BehaviorInstance Objects Are Concrete ItemsA First ExampleClasses Are Customized by InheritanceA Second ExampleClasses Are Attributes in ModulesClasses Can Intercept Python OperatorsA Third ExampleWhy Use Operator Overloading?The World’s Simplest Python ClassClasses Versus DictionariesChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
27. A More Realistic Example
Step 1: Making InstancesCoding ConstructorsTesting As You GoUsing Code Two WaysStep 2: Adding Behavior MethodsCoding MethodsStep 3: Operator OverloadingProviding Print DisplaysStep 4: Customizing Behavior by SubclassingCoding SubclassesAugmenting Methods: The Bad WayAugmenting Methods: The Good WayPolymorphism in ActionInherit, Customize, and ExtendOOP: The Big IdeaStep 5: Customizing Constructors, TooOOP Is Simpler Than You May ThinkOther Ways to Combine ClassesStep 6: Using Introspection ToolsSpecial Class AttributesA Generic Display ToolInstance Versus Class AttributesName Considerations in Tool ClassesOur Classes’ Final FormStep 7 (Final): Storing Objects in a DatabasePickles and ShelvesStoring Objects on a Shelve DatabaseExploring Shelves InteractivelyUpdating Objects on a ShelveFuture DirectionsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
28. Class Coding Details
The class StatementGeneral FormExampleMethodsMethod ExampleCalling Superclass ConstructorsOther Method Call PossibilitiesInheritanceAttribute Tree ConstructionSpecializing Inherited MethodsClass Interface TechniquesAbstract SuperclassesPython 2.6 and 3.0 Abstract SuperclassesNamespaces: The Whole StorySimple Names: Global Unless AssignedAttribute Names: Object NamespacesThe “Zen” of Python Namespaces: Assignments Classify NamesNamespace DictionariesNamespace LinksDocumentation Strings RevisitedClasses Versus ModulesChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
29. Operator Overloading
The BasicsConstructors and Expressions: __init__ and __sub__Common Operator Overloading MethodsIndexing and Slicing: __getitem__ and __setitem__Intercepting SlicesIndex Iteration: __getitem__Iterator Objects: __iter__ and __next__User-Defined IteratorsMultiple Iterators on One ObjectMembership: __contains__, __iter__, and __getitem__Attribute Reference: __getattr__ and __setattr__Other Attribute Management ToolsEmulating Privacy for Instance Attributes: Part 1String Representation: __repr__ and __str__Right-Side and In-Place Addition: __radd__ and __iadd__In-Place AdditionCall Expressions: __call__Function Interfaces and Callback-Based CodeComparisons: __lt__, __gt__, and OthersThe 2.6 __cmp__ Method (Removed in 3.0)Boolean Tests: __bool__ and __len__Object Destruction: __del__Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
30. Designing with Classes
Python and OOPOverloading by Call Signatures (or Not)OOP and Inheritance: “Is-a” RelationshipsOOP and Composition: “Has-a” RelationshipsStream Processors RevisitedOOP and Delegation: “Wrapper” ObjectsPseudoprivate Class AttributesName Mangling OverviewWhy Use Pseudoprivate Attributes?Methods Are Objects: Bound or UnboundUnbound Methods are Functions in 3.0Bound Methods and Other Callable ObjectsMultiple Inheritance: “Mix-in” ClassesCoding Mix-in Display ClassesListing instance attributes with __dict__Listing inherited attributes with dirListing attributes per object in class treesClasses Are Objects: Generic Object FactoriesWhy Factories?Other Design-Related TopicsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
31. Advanced Class Topics
Extending Built-in TypesExtending Types by EmbeddingExtending Types by SubclassingThe “New-Style” Class ModelNew-Style Class ChangesType Model ChangesImplications for type testingAll objects derive from “object”Diamond Inheritance ChangeDiamond inheritance exampleExplicit conflict resolutionScope of search order changeNew-Style Class ExtensionsInstance SlotsSlots and generic codeMultiple __slot__ lists in superclassesClass Properties__getattribute__ and DescriptorsMetaclassesStatic and Class MethodsWhy the Special Methods?Static Methods in 2.6 and 3.0Static Method AlternativesUsing Static and Class MethodsCounting Instances with Static MethodsCounting Instances with Class MethodsCounting instances per class with class methodsDecorators and Metaclasses: Part 1Function Decorator BasicsA First Function Decorator ExampleClass Decorators and MetaclassesFor More DetailsClass GotchasChanging Class Attributes Can Have Side EffectsChanging Mutable Class Attributes Can Have Side Effects, TooMultiple Inheritance: Order MattersMethods, Classes, and Nested ScopesDelegation-Based Classes in 3.0: __getattr__ and built-ins“Overwrapping-itis”Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: AnswersTest Your Knowledge: Part VI Exercises
VII. Exceptions and Tools
32. Exception Basics
Why Use Exceptions?Exception RolesExceptions: The Short StoryDefault Exception HandlerCatching ExceptionsRaising ExceptionsUser-Defined ExceptionsTermination ActionsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
33. Exception Coding Details
The try/except/else Statementtry Statement ClausesThe try else ClauseExample: Default BehaviorExample: Catching Built-in ExceptionsThe try/finally StatementExample: Coding Termination Actions with try/finallyUnified try/except/finallyUnified try Statement SyntaxCombining finally and except by NestingUnified try ExampleThe raise StatementPropagating Exceptions with raisePython 3.0 Exception Chaining: raise fromThe assert StatementExample: Trapping Constraints (but Not Errors!)with/as Context ManagersBasic UsageThe Context Management ProtocolChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
34. Exception Objects
Exceptions: Back to the FutureString Exceptions Are Right Out!Class-Based ExceptionsCoding Exceptions ClassesWhy Exception Hierarchies?Built-in Exception ClassesBuilt-in Exception CategoriesDefault Printing and StateCustom Print DisplaysCustom Data and BehaviorProviding Exception DetailsProviding Exception MethodsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
35. Designing with Exceptions
Nesting Exception HandlersExample: Control-Flow NestingExample: Syntactic NestingException IdiomsExceptions Aren’t Always ErrorsFunctions Can Signal Conditions with raiseClosing Files and Server ConnectionsDebugging with Outer try StatementsRunning In-Process TestsMore on sys.exc_infoException Design Tips and GotchasWhat Should Be WrappedCatching Too Much: Avoid Empty except and ExceptionCatching Too Little: Use Class-Based CategoriesCore Language SummaryThe Python ToolsetDevelopment Tools for Larger ProjectsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: AnswersTest Your Knowledge: Part VII Exercises
VIII. Advanced Topics
36. Unicode and Byte Strings
String Changes in 3.0String BasicsCharacter Encoding SchemesPython’s String TypesText and Binary FilesPython 3.0 Strings in ActionLiterals and Basic PropertiesConversionsCoding Unicode StringsCoding ASCII TextCoding Non-ASCII TextEncoding and Decoding Non-ASCII textOther Unicode Coding TechniquesConverting EncodingsCoding Unicode Strings in Python 2.6Source File Character Set Encoding DeclarationsUsing 3.0 Bytes ObjectsMethod CallsSequence OperationsOther Ways to Make bytes ObjectsMixing String TypesUsing 3.0 (and 2.6) bytearray ObjectsUsing Text and Binary FilesText File BasicsText and Binary Modes in 3.0Type and Content MismatchesUsing Unicode FilesReading and Writing Unicode in 3.0Manual encodingFile output encodingFile input decodingDecoding mismatchesHandling the BOM in 3.0Unicode Files in 2.6Other String Tool Changes in 3.0The re Pattern Matching ModuleThe struct Binary Data ModuleThe pickle Object Serialization ModuleXML Parsing ToolsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
37. Managed Attributes
Why Manage Attributes?Inserting Code to Run on Attribute AccessPropertiesThe BasicsA First ExampleComputed AttributesCoding Properties with DecoratorsDescriptorsThe BasicsDescriptor method argumentsRead-only descriptorsA First ExampleComputed AttributesUsing State Information in DescriptorsHow Properties and Descriptors Relate__getattr__ and __getattribute__The BasicsAvoiding loops in attribute interception methodsA First ExampleComputed Attributes__getattr__ and __getattribute__ ComparedManagement Techniques ComparedIntercepting Built-in Operation AttributesDelegation-Based Managers RevisitedExample: Attribute ValidationsUsing Properties to ValidateSelf-test codeUsing Descriptors to ValidateUsing __getattr__ to ValidateUsing __getattribute__ to ValidateChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
38. Decorators
What’s a Decorator?Managing Calls and InstancesManaging Functions and ClassesUsing and Defining DecoratorsWhy Decorators?The BasicsFunction DecoratorsUsageImplementationSupporting method decorationClass DecoratorsUsageImplementationSupporting multiple instancesDecorator NestingDecorator ArgumentsDecorators Manage Functions and Classes, TooCoding Function DecoratorsTracing CallsState Information Retention OptionsClass instance attributesEnclosing scopes and globalsEnclosing scopes and nonlocalsFunction attributesClass Blunders I: Decorating Class MethodsUsing nested functions to decorate methodsUsing descriptors to decorate methodsTiming CallsAdding Decorator ArgumentsCoding Class DecoratorsSingleton ClassesTracing Object InterfacesClass Blunders II: Retaining Multiple InstancesDecorators Versus Manager FunctionsWhy Decorators? (Revisited)Managing Functions and Classes DirectlyExample: “Private” and “Public” AttributesImplementing Private AttributesImplementation Details IInheritance versus delegationDecorator argumentsState retention and enclosing scopesUsing __dict__ and __slots__Generalizing for Public Declarations, TooImplementation Details IIUsing __X pseudoprivate namesBreaking privacyDecorator tradeoffsOpen IssuesCaveat: operator overloading methods fail to delegate under 3.0Implementation alternatives: __getattribute__ inserts, call stack inspectionPython Isn’t About ControlExample: Validating Function ArgumentsThe GoalA Basic Range-Testing Decorator for Positional ArgumentsGeneralizing for Keywords and Defaults, TooImplementation DetailsFunction introspectionArgument assumptionsMatching algorithmOpen IssuesDecorator Arguments Versus Function AnnotationsOther Applications: Type Testing (If You Insist!)Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
39. Metaclasses
To Metaclass or Not to MetaclassIncreasing Levels of MagicThe Downside of “Helper” FunctionsMetaclasses Versus Class Decorators: Round 1The Metaclass ModelClasses Are Instances of typeMetaclasses Are Subclasses of TypeClass Statement ProtocolDeclaring MetaclassesCoding MetaclassesA Basic MetaclassCustomizing Construction and InitializationOther Metaclass Coding TechniquesUsing simple factory functionsOverloading class creation calls with metaclassesOverloading class creation calls with normal classesInstances Versus InheritanceExample: Adding Methods to ClassesManual AugmentationMetaclass-Based AugmentationMetaclasses Versus Class Decorators: Round 2Decorator-based augmentationManaging instances instead of classesExample: Applying Decorators to MethodsTracing with Decoration ManuallyTracing with Metaclasses and DecoratorsApplying Any Decorator to MethodsMetaclasses Versus Class Decorators: Round 3Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
IX. Appendixes
A. Installation and Configuration
Installing the Python InterpreterIs Python Already Present?Where to Get PythonInstallation StepsConfiguring PythonPython Environment VariablesHow to Set Configuration OptionsUnix/Linux shell variablesDOS variables (Windows)Windows environment variable GUIWindows registryPath filesPython Command-Line OptionsFor More Help
B. Solutions to End-of-Part Exercises
Part I, Getting StartedPart II, Types and OperationsPart III, Statements and SyntaxPart IV, FunctionsPart V, ModulesPart VI, Classes and OOPPart VII, Exceptions and Tools
Index
About the Author
Colophon
Copyright

Overview

Google and YouTube use Python because it's highly adaptable, easy to maintain, and allows for rapid development. If you want to write high-quality, efficient code that's easily integrated with other languages and tools, this hands-on book will help you be productive with Python quickly -- whether you're new to programming or just new to Python. It's an easy-to-follow self-paced tutorial, based on author and Python expert Mark Lutz's popular training course.

Each chapter contains a stand-alone lesson on a key component of the language, and includes a unique Test Your Knowledge section with practical exercises and quizzes, so you can practice new skills and test your understanding as you go. You'll find lots of annotated examples and illustrations to help you get started with Python 3.0.

Learn about Python's major built-in object types, such as numbers, lists, and dictionariesCreate and process objects using Python statements, and learn Python's general syntax modelStructure and reuse code using functions, Python's basic procedural toolLearn about Python modules: packages of statements, functions, and other tools, organized into larger componentsDiscover Python's object-oriented programming tool for structuring codeLearn about the exception-handling model, and development tools for writing larger programsExplore advanced Python tools including decorators, descriptors, metaclasses, and Unicode processing

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780596805395Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills