Mastering Object-Oriented Python

Build powerful applications with reusable code using OOP design patterns and Python 3.7, 2nd Edition

Steven F. Lott

• Publisher: Packt Publishing
• Year: 2019
• ISBN:
  9781789531404
• Edition: 2
• Topic: Informatica
• Subtopic: Programmazione in Python

Gain comprehensive insights into programming practices, and code portability and reuse to build flexible and maintainable apps using object-oriented principles

Key Features

• Extend core OOP techniques to increase integration of classes created with Python
• Explore various Python libraries for handling persistence and object serialization
• Learn alternative approaches for solving programming problems, with different attributes to address your problem domain

Book Description

Object-oriented programming (OOP) is a relatively complex discipline to master, and it can be difficult to see how general principles apply to each language's unique features. With the help of the latest edition of Mastering Objected-Oriented Python, you'll be shown how to effectively implement OOP in Python, and even explore Python 3.x.

Complete with practical examples, the book guides you through the advanced concepts of OOP in Python, and demonstrates how you can apply them to solve complex problems in OOP. You will learn how to create high-quality Python programs by exploring design alternatives and determining which design offers the best performance. Next, you'll work through special methods for handling simple object conversions and also learn about hashing and comparison of objects. As you cover later chapters, you'll discover how essential it is to locate the best algorithms and optimal data structures for developing robust solutions to programming problems with minimal computer processing. Finally, the book will assist you in leveraging various Python features by implementing object-oriented designs in your programs.

By the end of this book, you will have learned a number of alternate approaches with different attributes to confidently solve programming problems in Python.

What you will learn

• Explore a variety of different design patterns for the __init__() method
• Learn to use Flask to build a RESTful web service
• Discover SOLID design patterns and principles
• Use the features of Python 3's abstract base
• Create classes for your own applications
• Design testable code using pytest and fixtures
• Understand how to design context managers that leverage the 'with' statement
• Create a new type of collection using standard library and design techniques
• Develop new number types above and beyond the built-in classes of numbers

Who this book is for

This book is for developers who want to use Python to create efficient programs. A good understanding of Python programming is required to make the most out of this book. Knowledge of concepts related to object-oriented design patterns will also be useful.

Section 1: Tighter Integration Via Special Methods

We'll extend the core object-oriented programming techniques to allow for increased integration of the classes we create with other features of Python.

The following chapters will be covered in this section:

• Chapter 1, Preliminaries, Tools, and Techniques
• Chapter 2, The __init__() Method
• Chapter 3, Integrating Seamlessly – Basic Special Methods
• Chapter 4, Attribute Access, Properties, and Descriptors
• Chapter 5, The ABCs of Consistent Design
• Chapter 6, Using Callables and Contexts
• Chapter 7, Creating Containers and Collections
• Chapter 8, Creating Numbers
• Chapter 9, Decorators and Mixins – Cross-Cutting Aspects

Preliminaries, Tools, and Techniques

To make the design issues in the balance of the book more clear, we need to look at some the problems that serve as motivation. One of these is using object-oriented programming (OOP) for simulation. Simulation was one of the early problem domains for OOP. This is an area where OOP works out particularly elegantly.

We've chosen a problem domain that's relatively simple: the strategies for playing the game of blackjack. We don't want to endorse gambling; indeed, a bit of study will show that the game is stacked heavily against the player. This should reveal that most casino gambling is little more than a tax on the innumerate.

The first section of this chapter will review the rules of the game of Blackjack. After looking at the card game, the bulk of this chapter will provide some background in tools that are essential for writing complete Python programs and packages. We'll look at the following concepts:

• The Python runtime environment and how the special method names implement the language features
• Integrated Development Environments (IDEs)
• Using the pylint or black tools to create a uniform style
• Using type hints and the mypy tool to establish proper use of functions, classes, and variables
• Using timeit for performance testing
• Using unittest, doctest, and pytest for unit testing
• Using sphinx and RST-based markup to create usable documentation

While some of these tools are part of the Python standard library, most of them are outside the library. We'll discuss installation of tools when we talk about the Python runtime in general.

This book will try to avoid digressing into the foundations of Python OOP. We're assuming that you've already read Packt's Python3 Object-Oriented Programming. We don't want to repeat things that are nicely stated elsewhere. We will focus on Python 3.

We'll refer to a number of common object-oriented design patterns and will try to avoid repeating the presentation in Packt's Learning Python Design Patterns.

We'll cover the following topics in this chapter:

• About the Blackjack game
• The Python runtime and special methods
• Interaction, scripting and tools
• Selecting an IDE
• Consistency and style
• Type hints and the mypy program
• Performance – the timeit module
• Testing – unittest and doctest
• Documentation – sphinx and RST markup
• Installing components

Technical requirements

The code files for this chapter can be found at https://git.io/fj2UB.

About the Blackjack game

Many of the examples in the book will center on simulations of a process with a number of moderately complex state changes. The card game of Blackjack involves a few rules and a few state changes during play. If you're unfamiliar with the game of Blackjack, here's an overview.

The objective of the game is to accept cards from the dealer to create a hand that has a point total that is between the dealer's total and twenty-one. The dealer's hand is only partially revealed, forcing the player to make a decision without knowing the dealer's total or the subsequent cards from the deck.

The number cards (2 to 10) have point values equal to the number. The face cards (Jack, Queen, and King) are worth 10 points. The Ace is worth either eleven points or one point. When using an ace as eleven points, the value of the hand is soft. When using an ace as one point, the value is hard.

A hand with an Ace and a seven, therefore, has a hard total of eight and a soft total of 18. This leads the player to choose to take extra cards. If the dealer is showing a face card, it's very likely the dealer is holding twenty points, and the player may not want to risk taking another card.

Each suit has four two-card combinations that total 21. These are all called Blackjack, even though only one of the four combinations involves a Jack. These combinations often provide a bonus payout, because there are only four of them available.

Most of the game is about proper choice of cards. There is, of course, a betting element. The distinction between playing and betting is made somewhat more complicated by the provision to split one hand into two hands. This is allowed when the player's two cards have the same rank. This option will be detailed in the next section on how the game is played.

Playing the game

The mechanics of play generally work as follows. The details can vary, but the outline is similar:

• First, the player and dealer each get two cards. The player, of course, knows the value of both of their cards. They're dealt face up in a casino.
• One of the dealer's cards is revealed to the player. It's displayed face up. The player, therefore, knows a little bit about the dealer's hand, but not everything. This is typical of more complex simulations where partial information is available and statistical modeling is required to make appropriate decisions.
• If the dealer has an Ace showing, the player is offered the opportunity to place an additional insurance bet. This is a special case, and is typical of more complex simulations where there are exceptions.
• For the balance of the game, the player can elect to receive cards, or stop receiving cards. There are four choices available:
  • The player can hit, which means take another card.
  • They player can or stand or stand pat with the cards dealt.
  • If the player's cards match, the hand can be split. This entails an additional bet, and the two hands are played separately.
  • The player can double their bet before taking one last card. This is called doubling down.

The final evaluation of the hand works as follows:

• If the player went over 21, the hand is a bust, the player loses, and the dealer's face-down card is irrelevant. This provides an advantage to the dealer.
• If the player's total is 21 or under, then t...