Book Image

Python Object-Oriented Programming - Fourth Edition

By : Steven F. Lott, Dusty Phillips
2 (1)
Book Image

Python Object-Oriented Programming - Fourth Edition

2 (1)
By: Steven F. Lott, Dusty Phillips

Overview of this book

Object-oriented programming (OOP) is a popular design paradigm in which data and behaviors are encapsulated in such a way that they can be manipulated together. Python Object-Oriented Programming, Fourth Edition dives deep into the various aspects of OOP, Python as an OOP language, common and advanced design patterns, and hands-on data manipulation and testing of more complex OOP systems. These concepts are consolidated by open-ended exercises, as well as a real-world case study at the end of every chapter, newly written for this edition. All example code is now compatible with Python 3.9+ syntax and has been updated with type hints for ease of learning. Steven and Dusty provide a comprehensive, illustrative tour of important OOP concepts, such as inheritance, composition, and polymorphism, and explain how they work together with Python’s classes and data structures to facilitate good design. In addition, the book also features an in-depth look at Python’s exception handling and how functional programming intersects with OOP. Two very powerful automated testing systems, unittest and pytest, are introduced. The final chapter provides a detailed discussion of Python's concurrent programming ecosystem. By the end of the book, you will have a thorough understanding of how to think about and apply object-oriented principles using Python syntax and be able to confidently create robust and reliable programs.

Related Content you might be interested in

Current Title:

Small book image
Python Object-Oriented Programming - Fourth Edition
Steven F. Lott | Dusty Phillips
Jul, 2021 | 714 pages
Small book image
Modern Python Cookbook.
Steven F Lott
Jul, 2020 | 822 pages
Small book image
Mastering Object-Oriented Python.
Steven F Lott
Jun, 2019 | 770 pages
Small book image
Functional Python Programming
Steven F Lott
Dec, 2022 | 576 pages
Table of Contents (17 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
1
Object-Oriented Design
Object-Oriented Design
Introducing object-oriented
Objects and classes
Specifying attributes and behaviors
Hiding details and creating the public interface
Composition
Inheritance
Case study
Recall
Exercises
Summary
Free Chapter
2
Objects in Python
Objects in Python
Introducing type hints
Creating Python classes
Modules and packages
Who can access my data?
Third-party libraries
Case study
Recall
Exercises
Summary
3
When Objects Are Alike
When Objects Are Alike
Basic inheritance
Multiple inheritance
Polymorphism
Case study
Recall
Exercises
Summary
4
Expecting the Unexpected
Expecting the Unexpected
Raising exceptions
Case study
Recall
Exercises
Summary
5
When to Use Object-Oriented Programming
When to Use Object-Oriented Programming
Treat objects as objects
Adding behaviors to class data with properties
Manager objects
Case study
Recall
Exercises
Summary
6
Abstract Base Classes and Operator Overloading
Abstract Base Classes and Operator Overloading
Creating an abstract base class
Operator overloading
Extending built-ins
Metaclasses
Case study
Recall
Exercises
Summary
7
Python Data Structures
Python Data Structures
Empty objects
Tuples and named tuples
Dataclasses
Dictionaries
Lists
Sets
Three types of queues
Case study
Recall
Exercises
Summary
8
The Intersection of Object-Oriented and Functional Programming
The Intersection of Object-Oriented and Functional Programming
Python built-in functions
An alternative to method overloading
Functions are objects, too
File I/O
Case study
Recall
Exercises
Summary
9
Strings, Serialization, and File Paths
Strings, Serialization, and File Paths
Strings
Regular expressions
Filesystem paths
Serializing objects
Case study
Recall
Exercises
Summary
10
The Iterator Pattern
The Iterator Pattern
Design patterns in brief
Iterators
Comprehensions
Generator functions
Case study
Recall
Exercises
Summary
11
Common Design Patterns
Common Design Patterns
The Decorator pattern
The Observer pattern
The Strategy pattern
The Command pattern
The State pattern
The Singleton pattern
Case study
Recall
Exercises
Summary
12
Advanced Design Patterns
Advanced Design Patterns
The Adapter pattern
The Façade pattern
The Flyweight pattern
The Abstract Factory pattern
The Composite pattern
The Template pattern
Case study
Recall
Exercises
Summary
13
Testing Object-Oriented Programs
Testing Object-Oriented Programs
Why test?
Unit testing with unittest
Unit testing with pytest
Imitating objects using Mocks
How much testing is enough?
Testing and development
Case study
Recall
Exercises
Summary
14
Concurrency
Concurrency
Background on concurrent processing
Threads
Multiprocessing
Futures
AsyncIO
The dining philosophers benchmark
Case study
Recall
Exercises
Summary
15
Other Books You May Enjoy
Other Books You May Enjoy
16
Index
Index

The State pattern

The State pattern is structurally similar to the Strategy pattern, but its intent and purpose are very different. The goal of the State pattern is to represent state transition systems: systems where an object's behavior is constrained by the state it's in, and there are narrowly defined transitions to other states.

To make this work, we need a manager or context class that provides an interface for switching states. Internally, this class contains a pointer to the current state. Each state knows what other states it is allowed to be in and will transition to those states depending on the actions invoked upon it.

Here's how it looks in UML:

Figure 11.7: State pattern in UML

The State pattern decomposes the problem into two types of classes: the Core class and multiple State classes. The Core class maintains the current state, and forwards actions to a current state object. The State objects are typically hidden from any other objects...

Previous Section
End of Section 6
Next Section