Name: Clean Code in Python, 2nd Edition
Author: Mariano Anaya

Clean Code in Python, Second Edition will help you understand the problems that arise due to inefficient code formatting, and more importantly, demonstrate how to correct them.

Clean Code in Python, 2nd Edition

Python

Preface

In this chapter, we will explore the first concepts related to clean code, starting with what it is and what it means. The main goal of the chapter is to understand that clean code is not just a nice thing to have or a luxury in software projects. It's a necessity. Without quality code, the project will face the perils of failing due to an accumulation of technical debt ( technical debt is something we'll discuss at length later in the chapter, so don't worry if you haven't heard the term before).

Introduction, Code Formatting, and Tools

In this chapter, we will explore the way ideas are expressed in Python, with its own peculiarities. If you are familiar with the standard ways of accomplishing some tasks in programming (such as getting the last element of a list, iterating, and searching), or if you come from other programming languages (such as C, C++, and Java), then you will find that, in general, Python provides its own mechanism for most common tasks.

Pythonic Code

This is a book about software construction with Python. Good software is built from a good design. By saying things such as clean code, you may be thinking that we will explore good practices that relate only to the implementation details of the software, instead of its design. However, this assumption would be wrong since the code is not something different from the design—the code is the design.

General Traits of Good Code

In this chapter, we will continue to explore concepts of clean design applied to Python. In particular, we will review the SOLID principles and how to implement them in a Pythonic way. These principles entail a series of good practices to achieve better-quality software. In case some of you aren't aware of what SOLID stands for, here it is:

The SOLID Principles

In this chapter, we will explore decorators and see how they are useful in many situations where we want to improve our design. We will start by first exploring what decorators are, how they work, and how they are implemented.

Using Decorators to Improve&nbsp;Our Code

This chapter introduces a new concept that is more advanced in Python development since it features descriptors. Moreover, descriptors are not something programmers of other languages are familiar with, so there are no easy analogies or parallelisms to make.

Getting More Out of Our Objects with Descriptors

Generators are another one of those features that makes Python a peculiar language over more traditional ones. In this chapter, we will explore their rationale, why they were introduced in the language, and the problems they solve. We will also cover how to address problems idiomatically by using generators, and how to make our generators (or any iterable, for that matter) Pythonic.

Generators, Iterators, and Asynchronous Programming

The ideas explored in this chapter are fundamental pillars in the global context of the book because of their importance to our ultimate goal: to write better and more maintainable software.

Unit Testing and Refactoring

Design patterns have been a widespread topic in software engineering since their original inception in the famous Gang of Four ( GoF ) book, Design Patterns: Elements of Reusable Object-Oriented Software . Design patterns help to solve common problems with abstractions that work for certain scenarios. When they are implemented properly, the general design of the solution can benefit from them.

Common Design Patterns

In this final chapter, we focus on how everything fits together in the design of a whole system. This is more of a theoretical chapter. Given the nature of the topic, it would be too complex to delve down into the more low-level details. Besides, the point is precisely to escape from those details, assume that all the principles explored in previous chapters are assimilated, and focus on the design of a system at scale.

Clean Code in Python, 2nd Edition

About the course

Author

Course Outline

Reviews