Python 3 Object-Oriented Programming, Third Edition by Dusty Phillips -- Read -- Imperial Library of Trantor

Index

Title Page Copyright and Credits

Python 3 Object-Oriented Programming Third Edition

Packt Upsell

Why subscribe? Packt.com

Contributors

About the author About the reviewers Packt is searching for authors like you

Preface

Who this book is for What this book covers To get the most out of this book

Download the example code files Conventions used

Get in touch

Reviews

Object-Oriented Design

Introducing object-oriented Objects and classes Specifying attributes and behaviors

Data describes objects Behaviors are actions

Hiding details and creating the public interface Composition Inheritance

Inheritance provides abstraction Multiple inheritance

Case study Exercises Summary

Objects in Python

Creating Python classes

Adding attributes Making it do something

Talking to yourself More arguments

Initializing the object Explaining yourself

Modules and packages

Organizing modules

Absolute imports Relative imports

Organizing module content Who can access my data? Third-party libraries Case study Exercises Summary

When Objects Are Alike

Basic inheritance

Extending built-ins Overriding and super

Multiple inheritance

The diamond problem Different sets of arguments

Polymorphism Abstract base classes

Using an abstract base class Creating an abstract base class Demystifying the magic

Case study Exercises Summary

Expecting the Unexpected

Raising exceptions

Raising an exception The effects of an exception Handling exceptions The exception hierarchy Defining our own exceptions

Case study Exercises Summary

When to Use Object-Oriented Programming

Treat objects as objects Adding behaviors to class data with properties

Properties in detail Decorators – another way to create properties Deciding when to use properties

Manager objects

Removing duplicate code In practice

Case study Exercises Summary

Python Data Structures

Empty objects Tuples and named tuples

Named tuples

Dataclasses Dictionaries

Dictionary use cases Using defaultdict

Counter

Lists

Sorting lists

Sets Extending built-in functions Case study Exercises Summary

Python Object-Oriented Shortcuts

Python built-in functions

The len() function Reversed Enumerate File I/O Placing it in context

An alternative to method overloading

Default arguments Variable argument lists Unpacking arguments

Functions are objects too

Using functions as attributes Callable objects

Case study Exercises Summary

Strings and Serialization

Strings

String manipulation String formatting

Escaping braces f-strings can contain Python code Making it look right Custom formatters The format method

Strings are Unicode

Converting bytes to text Converting text to bytes

Mutable byte strings

Regular expressions

Matching patterns

Matching a selection of characters Escaping characters Matching multiple characters Grouping patterns together

Getting information from regular expressions

Making repeated regular expressions efficient

Filesystem paths Serializing objects

Customizing pickles Serializing web objects

Case study Exercises Summary

The Iterator Pattern

Design patterns in brief Iterators

The iterator protocol

Comprehensions

List comprehensions Set and dictionary comprehensions Generator expressions

Generators

Yield items from another iterable

Coroutines

Back to log parsing Closing coroutines and throwing exceptions The relationship between coroutines, generators, and functions

Case study Exercises Summary

Python Design Patterns I

The decorator pattern

A decorator example Decorators in Python

The observer pattern

An observer example

The strategy pattern

A strategy example Strategy in Python

The state pattern

A state example State versus strategy State transition as coroutines

The singleton pattern

Singleton implementation Module variables can mimic singletons

The template pattern

A template example

Exercises Summary

Python Design Patterns II

The adapter pattern The facade pattern The flyweight pattern The command pattern The abstract factory pattern The composite pattern Exercises Summary

Testing Object-Oriented Programs

Why test?

Test-driven development

Unit testing

Assertion methods Reducing boilerplate and cleaning up Organizing and running tests Ignoring broken tests

Testing with pytest

One way to do setup and cleanup A completely different way to set up variables Skipping tests with pytest

Imitating expensive objects How much testing is enough? Case study

Implementing it

Exercises Summary

Concurrency

Threads

The many problems with threads

Shared memory The global interpreter lock

Thread overhead

Multiprocessing

Multiprocessing pools Queues The problems with multiprocessing

Futures AsyncIO

AsyncIO in action Reading an AsyncIO Future AsyncIO for networking Using executors to wrap blocking code

Streams Executors

AsyncIO clients

Case study Exercises Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think

← Prev
Back
Next →

← Prev
Back
Next →