2.1 Technical requirements

The code for this chapter can be found in the PacktPublishing repository: https://github.com/PacktPublishing/Python-Object-Oriented-Programming-5E. Within that repository’s files, we’ll focus on the ch_02 directory.

This chapter will use the mypy tool, which is installed separately. Commands such as python -m pip install mypy will install this. If you’re using uv to manage your environment, then uvx tool install mypy will add mypy.

All of the examples were tested with Python 3.12 and 3.13. The uv tool can be used to test the code: uvx tox.

2.2 Introducing types and classes

Before we can look closely at creating classes, we need to talk a little bit about what a class is and how to be sure we’re using it correctly. One central idea is everything in Python is an object.

When we write literal values such as "Hello, world!" or 42, we’re actually creating objects that are instances of built-in classes. (Some languages have “primitive types” which aren’t objects; Python doesn’t have this complication.) We can fire up interactive Python and use the built-in type() function on the class that defines the properties of these objects:

>>> type("Hello, world!") 
<class ’str’> 
>>> type(42) 
<class ’int’>

The point of object-oriented programming is to solve a problem via a collaboration of objects. When we write 6 * 7, the multiplication of the two...

2.3 Creating Python classes

We don’t have to write much Python code to realize that Python is a very clean language. When we want to do something, we can just do it, without having to set up a bunch of prerequisite code. The ubiquitous hello world in Python, as you’ve likely seen, is only one line.

Similarly, the simplest class in Python 3 looks like this:

class MyFirstClass: 
    pass

There’s our first object-oriented program! For more information on the syntax, see section 9.3.1 (https://docs.python.org/3/tutorial/classes.html#class-definition-syntax) of the Python Tutorial. The class name must follow standard Python variable naming rules: it must start with a letter or underscore, and can only be comprised of letters, underscores, or numbers. In addition, the Python style guide PEP 8: ( https://peps.python.org/pep-0008/) recommends classes should be named using what PEP 8 calls CapWords notation: start with a capital...

2.4 Composition and decomposition

To see composition in action, we’ll look at a few, isolated elements of the design of a chess game.

A game of chess is played between two players, using a chess set featuring a board containing 64 positions in an grid. The board can have two sets of 16 pieces that can be moved in alternating turns by the two players in different ways. Each piece can capture other pieces. The board will be required to draw itself on the computer screen after each turn.

We’ve identified some of the possible objects in the description using italics, and a few key methods using bold. This is a common first step in turning an object-oriented analysis into a design. At this point, to emphasize composition, we’ll focus on the board, without worrying too much about the players or the different types of pieces.

The chess set is composed of a board and 32 pieces. The board further comprises 64 positions. The positions are commonly...

2.5 Who can access my data?

Object-oriented programming languages have a concept of access control. This is related to the concept of encapsulation. Some languages have a spectrum of access controls including private, protected, public, and final.

Python doesn’t do this. Instead, Python is kept very simple, and provides some guidelines and best practices. All methods and attributes on a class are publicly available. We often remind each other of this by saying “We’re all adults here.” There’s no need to declare a variable as private or protected when we can all see the source code.

If we want to suggest that a method should not be used publicly, we really need to put a note in docstrings indicating that the method is meant for internal use only. Ideally, we include an explanation of how the public-facing API works. We often supplement this with examples copied and pasted from REPL interaction; examples that can be tested by the...

2.6 Modules and packages

Now we know how to create classes and instantiate objects. You don’t need to write too many classes (or non-object-oriented code, for that matter) before you start to lose track of them. For small programs, we generally put all our classes into one file and add a little script at the end of the file to start them interacting. However, as our projects grow, it can become difficult to find the one class that needs to be edited among the many classes we’ve defined. This is where modules come in. Modules are Python files, nothing more. The single file in our small program is a module. Two Python files are two modules. If we have two files in the same folder, we can load a class from one module for use in the other module.

The Python module name is the file path’s stem; the name without the .py suffix. A file with the name model.py is a module named model. Module files are found by searching paths that includes the local directory...

2.7 Third-party libraries and virtual environments

Python ships with a lovely standard library, which is a collection of packages and modules that are available on every machine that runs Python. However, you’ll soon find that it doesn’t contain everything you need. When this happens, you have two options:

• Write a supporting library yourself

• Use somebody else’s code, a third-party library

We won’t be covering the details about turning your packages into libraries. If you have a problem you need to solve and you don’t feel like coding it (the best programmers are extremely lazy and prefer to reuse existing, proven code, rather than write their own), you can probably find the library you want on the Python Package Index (PyPI) at https://pypi.python.org/. Once you’ve identified a package that you want to install, you can use a tool called pip to install it.

2.8 Virtual environment management

There are several add-on tools for managing virtual environments more effectively. For example virtualenv, can be used instead of the built-in venv package.

In some cases, even more support and automation is required. If you’re working in a data science environment, you’ll probably want to use conda so you can install the complex statistical and scientific packages. The conda tool works with the Anaconda libraries. For more information, see https://docs.conda.io/en/latest/.

Tools such as uv and poetry can help with installing packages, creating packages, and managing virtual environments. For more information, see https://docs.astral.sh/uv/ and https://python-poetry.org, respectively.

When using a tool like uv, use the uv init command to initialize the project directory. The --app option sets up the common structure for building an application. The --lib option will prepare the kind of directory structure...

2.9 Recall

Some key points in this chapter are as follows:

• Python has optional type hints to help describe how data objects are related and what the parameters should be for methods and functions.

• We create Python classes with the class statement. We should initialize the attributes in the special __init__() method.

• Modules and packages are used as higher-level groupings of classes.

• We need to plan out the organization of module content. While the general advice is ”flat is better than nested,” there are a few cases where it can be helpful to have nested packages.

• Python has no notion of ”private” data. We often say ”we’re all adults here”; we can see the source code, and private declarations aren’t very helpful. This doesn’t change our design; it simply removes the need for...

2.10 Exercises

Write some object-oriented code. The goal is to use the principles and syntax you learned in this chapter to ensure you understand the topics we’ve covered. If you’ve been working on a Python project, go back over it and see whether there are some objects you can create and add properties or methods to. If your Python project is large, try dividing it into a few modules or even packages and play with the syntax. While a ”simple” script may expand when refactored into classes, there’s generally a gain in flexibility and extensibility.

If you don’t have such a project, try starting a new one. It doesn’t have to be something you intend to finish; just stub out some basic design parts. You don’t need to fully implement everything; often, just print("this method will do something") is all you need to get the overall design in place. This is called top-down design, in which...

2.11 Summary

In this chapter, we learned how to create classes and assign properties and methods in Python. Unlike many languages, Python differentiates between a constructor and an initializer. It has a relaxed attitude toward access control. There are many different levels of scope, including packages, modules, classes, and functions. We understood the difference between relative and absolute imports, and how to manage third-party packages that don’t come with Python.

In the next chapter, we’ll learn more about sharing an implementation among classes using inheritance.