Lott S.F., Phillips D. - Python Object-Oriented Programming, 4th Edition [2021, PDF/EPUB, ENG]

Chapter 1, Object-Oriented Design, introduces the core concepts underlying object-
oriented design. This provides a road map through the ideas of state and behavior,
attributes and methods, and how objects are grouped into classes. This chapter also
looks an encapsulation, inheritance, and composition. The case study for this chapter
introduces the machine learning problem, which is an implementation of a k-nearest
neighbors (k-NN) classifier.
Chapter 2, Objects in Python, shows how class definitions work in Python. This
will include the type annotations, called type hints, class definitions, modules,
and packages. We'll talk about practical considerations for class definition and
encapsulation. The case study will begin to implement some of the classes for the
k-NN classifier.
Chapter 3, When Objects Are Alike, addresses how classes are related to each other.
This will include how to make use of inheritance and multiple inheritance. We'll
look at the concept of polymorphism among the classes in a class hierarchy. The case
study will look at alternative designs for the distance computations used to find the
nearest neighbors.
Chapter 4, Expecting the Unexpected, looks closely at Python's exceptions and exception
handling. We'll look at the built-in exception hierarchy. We'll also look at how
unique exceptions can be defined to reflect a unique problem domain or application.
In the case study, we'll apply exceptions to data validation.
Chapter 5, When to Use Object-Oriented Programming, dives more deeply into design
techniques. This chapter will look at how attributes can be implemented via Python's
properties. We'll also look at the general concept of a manager for working with
collections of objects. The case study will apply these ideas to expand on the k-NN
classifier implementation.
Chapter 6, Abstract Base Classes and Operator Overloading, is a deep dive into the idea
of abstraction, and how Python supports abstract base classes. This will involve
comparing duck typing with more formal methods of Protocol definition. It will
include the techniques for overloading Python's built-in operators. It will also look at
metaclasses and how these can be used to modify class construction. The case study
will redefine some of the existing classes to show how abstraction must be used
carefully to lead to simplification of a design.
Chapter 7, Python Data Structures, examines a number of Python's built-in collections.
This chapter examines tuples, dictionaries, lists, and sets. It also looks at how
dataclasses and named tuples can simplify a design by providing a number of
common features of a class. The case study will revise some earlier class definitions
to make use of these new techniques.
Chapter 8, The Intersection of Object-Oriented and Functional Programming, looks at
Python constructs that aren't simply class definitions. While all of Python is object-
oriented, function definitions allow us to create callable objects without the clutter of
a class definition. We'll also look at Python's context manager construct and the with
statement. In the case study, we'll look at alternative designs that avoid some class
clutter.
Chapter 9, Strings, Serialization, and File Paths, covers the way objects are serialized as
strings and how strings can be parsed to create objects. We'll look at several physical
formats, including Pickle, JSON, and CSV. The case study will revisit how sample
data is loaded and processed by the k-NN classifier.
Chapter 10, The Iterator Pattern, describes the ubiquitous concept of iteration in
Python. All of the built-in collections are iterable, and this design pattern is central
to a great deal of how Python works. We'll look at Python comprehensions and
generator functions, also. The case study will revisit some earlier designs using
generator expressions and list comprehensions to partition samples for testing and
training.
Chapter 11, Common Design Patterns, looks at some common object-oriented design.
This will include the Decorator, Observer, Strategy, Command, State, and Singleton
design patterns.
Chapter 12, Advanced Design Patterns, looks at some more advanced object-oriented
design. This will include the Adapter, Façade, Flyweight, Abstract Factory,
Composite, and Template patterns.
Chapter 13, Testing Object-Oriented Programs, shows how to use unittest and pytest
to provide an automated unit test suite for a Python application. This will look
at some more advanced testing techniques, like using mock objects to isolate the
unit under test. The case study will show how to create test cases for the distance
computations covered in Chapter 3.
Chapter 14, Concurrency, looks at how we can make use of multi-core and multi-
processor computer systems to do computations rapidly and write software that is
responsive to external events. We'll look at threads and multiprocessing, as well as
Python's asyncio module. The case study will show how to use these techniques to
do hyperparameter tuning on the k-NN model.