book

Learning Python, 6th Edition

by Mark Lutz

February 2025

Intermediate to advanced

1172 pages

42h 20m

English

O'Reilly Media, Inc.

Book available

Read now

Unlock full access

Includes

Has Sandbox

PythonThis BookThis EditionMedia ChoicesUpdates and ExamplesConventions and ReuseAcknowledgments
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 ProgrammingGUIs and UIsInternet and Web ScriptingComponent IntegrationDatabase AccessRapid PrototypingNumeric and Scientific ProgrammingAnd More: AI, Games, Images, QA, Excel, Apps…What Are Python’s Technical Strengths?It’s Object-Oriented and FunctionalIt’s Free and OpenIt’s PortableIt’s PowerfulIt’s MixableIt’s Relatively Easy to UseIt’s Relatively Easy to LearnChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Introducing the Python InterpreterProgram ExecutionThe Programmer’s ViewPython’s ViewExecution-Model VariationsPython Implementation AlternativesStandalone ExecutablesFuture PossibilitiesChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Installing PythonInteractive CodeStarting an Interactive REPLWhere to Run: Code FoldersWhat Not to Type: Prompts and CommentsOther Python REPLsRunning Code InteractivelyWhy the Interactive Prompt?Program FilesA First ScriptRunning Files with Command LinesCommand-Line Usage VariationsOther Ways to Run FilesClicking and Tapping File IconsThe IDLE Graphical User InterfaceOther IDEs for PythonSmartphone AppsWebAssembly for BrowsersJupyter Notebooks for ScienceAhead-of-Time Compilers for SpeedRunning Code in CodeOther Launch OptionsWhich Option Should I Use?Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: AnswersTest Your Knowledge: Part I Exercises
The Python Conceptual HierarchyWhy Use Built-in Objects?Python’s Core Object TypesNumbersStringsSequence OperationsImmutabilityType-Specific MethodsGetting HelpOther Ways to Code StringsUnicode StringsListsSequence OperationsType-Specific OperationsBounds CheckingNestingComprehensionsDictionariesMapping OperationsNesting RevisitedMissing Keys: if TestsItem Iteration: for LoopsTuplesWhy Tuples?FilesUnicode and Byte FilesOther File-Like ToolsOther Object TypesSetsBooleans and NoneTypesType HintingUser-Defined ObjectsAnd Everything ElseChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Numeric Object BasicsNumeric LiteralsBuilt-in Numeric ToolsPython Expression OperatorsMixed Operators: PrecedenceParentheses Group SubexpressionsMixed Types Are Converted UpPreview: Operator Overloading and PolymorphismNumbers in ActionVariables and Basic ExpressionsNumeric Display FormatsComparison OperatorsDivision OperatorsInteger PrecisionComplex NumbersHex, Octal, and BinaryBitwise OperationsUnderscore Separators in NumbersOther Built-in Numeric ToolsOther Numeric ObjectsDecimal ObjectsFraction ObjectsSet ObjectsBoolean ObjectsNumeric ExtensionsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
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 EverywhereType Hinting: Optional, Unused, and Why?Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
String Object BasicsString LiteralsSingle and Double Quotes Are the SameEscape Sequences Are Special CharactersRaw Strings Suppress EscapesTriple Quotes and Multiline StringsStrings in ActionBasic OperationsIndexing and SlicingString Conversion Tools“Changing” Strings Part 1: Sequence OperationsString MethodsMethod Call SyntaxAll String Methods (Today)“Changing” Strings, Part 2: String MethodsMore String Methods: Parsing TextOther Common String MethodsString Formatting: The TriathlonString-Formatting OptionsThe String-Formatting ExpressionThe String-Formatting MethodThe F-String Formatting LiteralAnd the Winner Is…General Type CategoriesTypes Share Operation Sets by CategoriesMutable Types Can Be Changed in PlaceChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers

ListsLists in ActionBasic List OperationsIndexing and SlicingChanging Lists in PlaceMore List MethodsIteration, Comprehensions, and UnpackingOther List OperationsDictionariesDictionaries in ActionBasic Dictionary OperationsChanging Dictionaries in PlaceMore Dictionary MethodsOther Dictionary MakersDictionary ComprehensionsKey Insertion OrderingDictionary “Union” OperatorIntermission: Books DatabaseDictionary Usage TipsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
TuplesTuples in ActionWhy Lists and Tuples?Records Revisited: Named TuplesFilesOpening FilesUsing FilesFiles in ActionText and Binary Files: The Short StoryStoring Objects with ConversionsStoring Objects with pickleStoring Objects with JSONStoring Objects with Other ToolsFile Context ManagersOther File ToolsCore Types Review and SummaryObject FlexibilityReferences Versus CopiesComparisons, Equality, and TruthThe Meaning of True and False in PythonPython’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
The Python Conceptual Hierarchy RevisitedPython’s StatementsA Tale of Two ifsWhat Python AddsWhat Python RemovesWhy Indentation Syntax?A Few Special CasesA Quick Example: Interactive LoopsA Simple Interactive LoopDoing Math on User InputsHandling Errors by Testing InputsHandling Errors with try StatementsSupporting Floating-Point NumbersNesting Code Three Levels DeepChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
AssignmentsAssignment Syntax FormsBasic AssignmentsSequence AssignmentsExtended-Unpacking AssignmentsMultiple-Target AssignmentsAugmented AssignmentsNamed Assignment ExpressionsVariable Name RulesExpression StatementsExpression Statements and In-Place ChangesPrint OperationsThe print FunctionPrint Stream RedirectionChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
if StatementsGeneral FormatBasic ExamplesMultiple-Choice Selectionsmatch StatementsBasic match UsageAdvanced match UsagePython Syntax RevisitedBlock Delimiters: Indentation RulesStatement Delimiters: Lines and ContinuationsSpecial Syntax Cases in ActionTruth Values RevisitedThe if/else Ternary ExpressionChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
while LoopsGeneral FormatExamplesbreak, continue, pass, and the Loop elseGeneral Loop FormatpasscontinuebreakLoop elsefor LoopsGeneral FormatExamplesLoop Coding TechniquesCounter Loops: rangeSequence Scans: while, range, and forSequence Shufflers: range and lenSkipping Items: range and SlicesChanging Lists: range and ComprehensionsParallel Traversals: zipOffsets and Items: enumerateChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
IterationsThe Iteration ProtocolOther Built-in IterablesComprehensionsList Comprehension BasicsList Comprehensions and FilesExtended List Comprehension SyntaxComprehensions Cliff-HangerIteration ToolsOther Iteration TopicsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Python Documentation Sources# CommentsThe dir FunctionDocstrings and __doc__Pydoc: The help FunctionPydoc: HTML ReportsBeyond Docstrings: SphinxThe Standard ManualsWeb ResourcesCommon Coding GotchasChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: AnswersTest Your Knowledge: Part III Exercises
Why Use Functions?Function Coding OverviewBasic Function ToolsAdvanced Function ToolsGeneral Function Conceptsdef Statementsreturn Statementsdef Executes at Runtimelambda Makes Anonymous FunctionsA First Example: Definitions and CallsDefinitionCallsPolymorphism in PythonA Second Example: Intersecting SequencesDefinitionCallsPolymorphism RevisitedSegue: Local VariablesChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Python Scopes BasicsScopes OverviewName Resolution: The LEGB RuleScopes ExamplesThe Built-in ScopeThe global StatementProgram Design: Minimize Global VariablesProgram Design: Minimize Cross-File ChangesOther Ways to Access GlobalsNested Functions and ScopesNested Scopes OverviewNested Scopes ExamplesClosures and Factory FunctionsArbitrary Scope NestingThe nonlocal Statementnonlocal Basicsnonlocal in Actionnonlocal Boundary CasesState-Retention OptionsNonlocals: Changeable, Per-Call, LEGBGlobals: Changeable but SharedFunction Attributes: Changeable, Per-Call, Explicit Classes: Changeable, Per-Call, OOPAnd the Winner Is…Scopes and Argument DefaultsLoops Require Defaults, Not ScopesChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Argument-Passing BasicsArguments and Shared ReferencesAvoiding Mutable Argument ChangesSimulating Output Parameters and Multiple ResultsSpecial Argument-Matching ModesArgument Matching OverviewArgument Matching SyntaxArgument Passing DetailsKeyword and Default ExamplesArbitrary Arguments ExamplesKeyword-Only ArgumentsPositional-Only ArgumentsArgument Ordering: The Gritty DetailsDefinition OrderingCalls OrderingExample: The min Wakeup CallFull CreditBonus PointsThe Punch LineExample: Generalized Set FunctionsTesting the CodeExample: Rolling Your Own PrintUsing Keyword-Only ArgumentsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Function Design ConceptsRecursive FunctionsSummation with RecursionCoding AlternativesLoop Statements Versus RecursionHandling Arbitrary StructuresFunction Tools: Attributes, Annotations, Etc.The First-Class Object ModelFunction IntrospectionFunction AttributesFunction Annotations and DecorationsAnonymous Functions: lambdalambda BasicsWhy Use lambda?How (Not) to Obfuscate Your Python CodeScopes: lambdas Can Be Nested TooFunctional Programming ToolsMapping Functions over Iterables: mapSelecting Items in Iterables: filterCombining Items in Iterables: reduceChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Comprehensions: The Final ActList Comprehensions ReviewFormal Comprehension SyntaxExample: List Comprehensions and MatrixesGenerator Functions and ExpressionsGenerator Functions: yield Versus returnGenerator Expressions: Iterables Meet ComprehensionsGenerator Functions Versus Generator ExpressionsGenerator Odds and EndsExample: Shuffling SequencesScrambling SequencesPermutating SequencesExample: Emulating zip and mapCoding Your Own mapCoding Your Own zip and 2.X mapAsynchronous Functions: The Short StoryAsync BasicsThe Async Wrap-UpChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Benchmarking with Homegrown ToolsTimer Module: Take 1Timer Module: Take 2Timing Runner and ScriptIteration ResultsMore Module ModsBenchmarking with Python’s timeitBasic timeit UsageAutomating timeit BenchmarkingFunction GotchasLocal Names Are Detected StaticallyDefaults and Mutable ObjectsFunctions Without returnsMiscellaneous Function GotchasChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: AnswersTest Your Knowledge: Part IV Exercises
Module EssentialsWhy Use Modules?Python Program ArchitectureHow to Structure a ProgramImports and AttributesStandard-Library ModulesHow Imports WorkStep 1: Find ItStep 2: Compile It (Maybe)Step 3: Run ItThe Module Search PathSearch-Path ComponentsConfiguring the Search PathThe sys.path ListModule File SelectionPath Outliers: Standalones and PackagesChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Creating ModulesModule FilenamesOther Kinds of ModulesUsing ModulesThe import StatementThe from StatementThe from * StatementImports Happen Only OnceImports Are Runtime Assignmentsimport and from EquivalencePotential Pitfalls of the from StatementModule NamespacesHow Files Generate NamespacesNamespace Dictionaries: __dict__Attribute Name QualificationImports Versus ScopesNamespace NestingReloading Modulesreload Basicsreload Examplereload Odds and EndsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Using PackagesPackage ImportsPackages and the Module Search PathCreating PackagesBasic Package StructurePackage __init__.py FilesPackage __main__.py FilesWhy Packages?A Tale of Two SystemsThe Roles of __init__.py FilesPackage-Relative ImportsRelative and Absolute ImportsRelative-Import Rationales and Trade-OffsPackage-Relative Imports in ActionNamespace PackagesPython Import ModelsNamespace-Package RationalesThe Module Search AlgorithmNamespace Packages in ActionChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Module Design ConceptsData Hiding in ModulesMinimizing from * Damage: _X and __all__Managing Attribute Access: __getattr__ and __dir__Enabling Language Changes: __future__Dual-Usage Modes: __name__ and __main__Example: Unit Tests with __name__The as Extension for import and fromModule IntrospectionExample: Listing Modules with __dict__Importing Modules by Name StringRunning Code StringsDirect Calls: Two OptionsExample: Transitive Module ReloadsModule GotchasModule Name Clashes: Package and Package-Relative ImportsStatement 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
Why Use Classes?OOP from 30,000 FeetAttribute Inheritance SearchClasses and InstancesMethod CallsCoding Class TreesOperator OverloadingOOP Is About Code ReuseChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
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 ExampleThe World’s Simplest Python ClassClasses: Under the HoodRecords Revisited: Classes Versus DictionariesChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
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 Classes: CompositesStep 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 ShelfFuture DirectionsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
The class StatementGeneral Syntax and UsageExample: Class AttributesMethodsMethod ExampleOther Method-Call PossibilitiesInheritanceAttribute Tree ConstructionInheritance Fine PrintSpecializing Inherited MethodsClass Interface TechniquesAbstract SuperclassesNamespaces: The ConclusionSimple Names: Global Unless AssignedAttribute Names: Object NamespacesThe “Zen” of Namespaces: Assignments Classify NamesNested Classes: The LEGB Scopes Rule RevisitedNamespace Dictionaries: ReviewNamespace Links: A Tree ClimberDocumentation Strings RevisitedClasses Versus ModulesChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
The BasicsConstructors and Expressions: __init__ and __sub__Common Operator-Overloading MethodsIndexing and Slicing: __getitem__ and __setitem__Intercepting SlicesIntercepting Item AssignmentsBut __index__ Means As-IntegerIndex Iteration: __getitem__Iterable Objects: __iter__ and __next__User-Defined IterablesMultiple Iterators on One ObjectCoding Alternative: __iter__ Plus yieldMembership: __contains__, __iter__, and __getitem__Attribute Access: __getattr__ and __setattr__Attribute ReferenceAttribute Assignment and DeletionOther Attribute-Management ToolsEmulating Privacy for Instance Attributes: Part 1String Representation: __repr__ and __str__Why Two Display Methods?Display Usage NotesRight-Side and In-Place Ops: __radd__ and __iadd__Right-Side AdditionIn-Place AdditionCall Expressions: __call__Function Interfaces and Callback-Based CodeComparisons: __lt__, __gt__, and OthersBoolean Tests: __bool__ and __len__Object Destruction: __del__Destructor Usage NotesChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Python and OOPPolymorphism Means Interfaces, Not Call SignaturesOOP and Inheritance: “Is-a” RelationshipsOOP and Composition: “Has-a” RelationshipsStream Processors RevisitedOOP and Delegation: “Like-a” RelationshipsPseudoprivate Class AttributesName Mangling OverviewWhy Use Pseudoprivate Attributes?Method Objects: Bound or NotBound Methods in ActionClasses Are Objects: Generic Object FactoriesWhy Factories?Multiple Inheritance and the MROHow Multiple Inheritance WorksHow the MRO WorksAttribute Conflict ResolutionExample: “Mix-in” Attribute ListersExample: Mapping Attributes to Inheritance SourcesOther Design-Related TopicsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Extending Built-in Object TypesExtending Types by EmbeddingExtending Types by SubclassingThe Python Object ModelClasses Are Types Are ClassesSome Instances Are More Equal Than OthersThe Inheritance BifurcationThe Metaclass/Class DichotomyAnd One “object” to Rule Them All Advanced Attribute ToolsSlots: Attribute DeclarationsProperties: Attribute Accessors__getattribute__ and Descriptors: Attribute ImplementationsStatic and Class MethodsWhy the Special Methods?Plain-Function MethodsStatic Method AlternativesUsing Static and Class MethodsCounting Instances with Static MethodsCounting Instances with Class MethodsDecorators and MetaclassesFunction Decorator BasicsA First Look at User-Defined Function DecoratorsA First Look at Class Decorators and MetaclassesFor More DetailsThe super FunctionThe super BasicsThe super DetailsThe super Wrap-UpClass GotchasChanging Class Attributes Can Have Side EffectsChanging Mutable Class Attributes Can Have Side Effects, TooMultiple Inheritance: Order MattersScopes in Methods and ClassesMiscellaneous Class Gotchas“Overwrapping-itis”Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: AnswersTest Your Knowledge: Part VI Exercises
Why Use Exceptions?Exception RolesExceptions: The Short StoryDefault Exception HandlerCatching ExceptionsRaising ExceptionsUser-Defined ExceptionsTermination ActionsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
The try Statementtry Statement ClausesThe except and else ClausesThe finally ClauseCombined try ClausesThe raise StatementRaising ExceptionsThe except as hookScopes and except asPropagating Exceptions with raiseException Chaining: raise fromThe assert StatementExample: Trapping Constraints (but Not Errors!)The with Statement and Context ManagersBasic with UsageThe Context-Management ProtocolMultiple Context ManagersThe Termination-Handlers Shoot-OutChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Exception ClassesCoding Exceptions ClassesWhy Exception Hierarchies?Built-in Exception ClassesBuilt-in Exception CategoriesDefault Printing and StateCustom Print DisplaysCustom State and BehaviorProviding Exception DetailsProviding Exception MethodsException Groups: Yet Another Star!Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Nesting Exception HandlersExample: Control-Flow NestingExample: Syntactic NestingException IdiomsBreaking Out of Multiple Nested Loops: “go to”Exceptions Aren’t Always ErrorsFunctions Can Signal Conditions with raiseClosing Files and Server ConnectionsDebugging with Outer try StatementsRunning In-Process TestsMore on sys.exc_infoDisplaying Errors and TracebacksException Design Tips and GotchasWhat Should Be WrappedCatching Too Much: Avoid Empty except and ExceptionCatching Too Little: Use Class-Based CategoriesCore Language Wrap-UpThe Python ToolsetDevelopment Tools for Larger ProjectsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: AnswersTest Your Knowledge: Part VII Exercises
Unicode FoundationsCharacter RepresentationsCharacter EncodingsIntroducing Python String ToolsThe str ObjectThe bytes ObjectThe bytearray ObjectText and Binary FilesUsing Text StringsLiterals and Basic PropertiesString Type ConversionsCoding Unicode Strings in PythonSource-File Encoding DeclarationsUsing Byte StringsMethodsSequence OperationsFormattingOther Ways to Make BytesMixing String TypesThe bytearray ObjectUsing Text and Binary FilesText-File BasicsText and Binary ModesUnicode-Text FilesUnicode, Bytes, and Other String ToolsThe re Pattern-Matching ModuleThe struct Binary-Data ModuleThe pickle and json Serialization ModulesFilenames in open and Other Filename ToolsThe Unicode Twilight ZoneDropping the BOM in PythonUnicode Normalization: Whither Standard?Chapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
Why Manage Attributes?Inserting Code to Run on Attribute AccessPropertiesThe BasicsA First ExampleComputed AttributesCoding Properties with DecoratorsDescriptorsThe BasicsA First ExampleComputed AttributesUsing State Information in DescriptorsHow Properties and Descriptors Relate__getattr__ and __getattribute__The BasicsA First ExampleComputed Attributes__getattr__ and __getattribute__ ComparedManagement Techniques ComparedIntercepting Built-in Operation AttributesExample: Attribute ValidationsUsing Properties to ValidateUsing Descriptors to ValidateUsing __getattr__ to ValidateUsing __getattribute__ to ValidateChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
What’s a Decorator?Managing Calls and InstancesManaging Functions and ClassesUsing and Defining DecoratorsWhy Decorators?The BasicsFunction Decorator BasicsClass Decorator BasicsDecorator NestingDecorator ArgumentsDecorators Manage Functions and Classes, TooCoding Function DecoratorsTracing Function CallsDecorator State Retention OptionsClass Pitfall: Decorating MethodsTiming Function CallsAdding Decorator ArgumentsCoding Class DecoratorsSingleton ClassesTracing Object InterfacesClass Pitfall: Retaining Multiple InstancesExample: “Private” and “Public” AttributesImplementing Private AttributesImplementation Details IGeneralizing for Public DeclarationsImplementation Details IIDelegating Built-In OperationsExample: Validating Function ArgumentsThe GoalA Basic Range-Testing Decorator for Positional ArgumentsGeneralizing for Keywords and DefaultsImplementation DetailsOpen IssuesDecorator Arguments Versus Function AnnotationsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
To Metaclass or Not to MetaclassThe Downside of “Helper” FunctionsMetaclasses Versus Class Decorators: Round 1The Metaclass ModelClasses Are Instances of typeMetaclasses Are Subclasses of typeClass Statements Call a typeClass Statements Can Choose a typeMetaclass Method ProtocolCoding MetaclassesA Basic MetaclassCustomizing Construction and InitializationOther Metaclass Coding TechniquesManaging Classes with Metaclasses and DecoratorsInheritance: The FinaleMetaclass Versus SuperclassMetaclass InheritancePython Inheritance Algorithm: The Simple VersionPython Inheritance Algorithm: The Less Simple VersionThe Inheritance Wrap-UpMetaclass MethodsMetaclass Methods Versus Class MethodsOperator Overloading in Metaclass MethodsMetaclass Methods Versus Instance MethodsChapter SummaryTest Your Knowledge: QuizTest Your Knowledge: Answers
The Python TsunamiThe Python SandboxThe Python UpsideClosing ThoughtsWhere to Go from HereEncore: Print Your Own Completion Certificate!
Using Python on WindowsUsing Python on macOSUsing Python on LinuxUsing Python on AndroidUsing Python on iOSStandalone Apps and ExecutablesEtcetera
Part I, Getting StartedPart II, Objects and OperationsPart III, Statements and SyntaxPart IV, Functions and GeneratorsPart V, Modules and PackagesPart VI, Classes and OOPPart VII, Exceptions