Clean Code in Python
eBook - ePub

Clean Code in Python

Develop maintainable and efficient code, 2nd Edition

Mariano Anaya

Buch teilen
  1. 422 Seiten
  2. English
  3. ePUB (handyfreundlich)
  4. Über iOS und Android verfĂŒgbar
eBook - ePub

Clean Code in Python

Develop maintainable and efficient code, 2nd Edition

Mariano Anaya

Angaben zum Buch

Über dieses Buch

Tackle inefficiencies and errors the Pythonic wayKey Features‱ Enhance your coding skills using the new features introduced in Python 3.9‱ Implement the refactoring techniques and SOLID principles in Python‱ Apply microservices to your legacy systems by implementing practical techniquesBook DescriptionExperienced professionals in every field face several instances of disorganization, poor readability, and testability due to unstructured code. With updated code and revised content aligned to the new features of Python 3.9, this second edition of Clean Code in Python will provide you with all the tools you need to overcome these obstacles and manage your projects successfully. The book begins by describing the basic elements of writing clean code and how it plays a key role in Python programming. You will learn about writing efficient and readable code using the Python standard library and best practices for software design. The book discusses object-oriented programming in Python and shows you how to use objects with descriptors and generators. It will also show you the design principles of software testing and how to resolve problems by implementing software design patterns in your code. In the concluding chapter, we break down a monolithic application into a microservices-based one starting from the code as the basis for a solid platform. By the end of this clean code book, you will be proficient in applying industry-approved coding practices to design clean, sustainable, and readable real-world Python code.What you will learn‱ Set up a productive development environment by leveraging automatic tools‱ Leverage the magic methods in Python to write better code, abstracting complexity away and encapsulating details‱ Create advanced object-oriented designs using unique features of Python, such as descriptors‱ Eliminate duplicated code by creating powerful abstractions using software engineering principles of object-oriented design‱ Create Python-specific solutions using decorators and descriptors‱ Refactor code effectively with the help of unit tests‱ Build the foundations for solid architecture with a clean code base as its cornerstoneWho this book is forThis book is designed to benefit new as well as experienced programmers. It will appeal to team leads, software architects and senior software engineers who would like to write Pythonic code to save on costs and improve efficiency. The book assumes that you have a strong understanding of programming

HĂ€ufig gestellte Fragen

Wie kann ich mein Abo kĂŒndigen?
Gehe einfach zum Kontobereich in den Einstellungen und klicke auf „Abo kĂŒndigen“ – ganz einfach. Nachdem du gekĂŒndigt hast, bleibt deine Mitgliedschaft fĂŒr den verbleibenden Abozeitraum, den du bereits bezahlt hast, aktiv. Mehr Informationen hier.
(Wie) Kann ich BĂŒcher herunterladen?
Derzeit stehen all unsere auf MobilgerĂ€te reagierenden ePub-BĂŒcher zum Download ĂŒber die App zur VerfĂŒgung. Die meisten unserer PDFs stehen ebenfalls zum Download bereit; wir arbeiten daran, auch die ĂŒbrigen PDFs zum Download anzubieten, bei denen dies aktuell noch nicht möglich ist. Weitere Informationen hier.
Welcher Unterschied besteht bei den Preisen zwischen den AboplÀnen?
Mit beiden AboplÀnen erhÀltst du vollen Zugang zur Bibliothek und allen Funktionen von Perlego. Die einzigen Unterschiede bestehen im Preis und dem Abozeitraum: Mit dem Jahresabo sparst du auf 12 Monate gerechnet im Vergleich zum Monatsabo rund 30 %.
Was ist Perlego?
Wir sind ein Online-Abodienst fĂŒr LehrbĂŒcher, bei dem du fĂŒr weniger als den Preis eines einzelnen Buches pro Monat Zugang zu einer ganzen Online-Bibliothek erhĂ€ltst. Mit ĂŒber 1 Million BĂŒchern zu ĂŒber 1.000 verschiedenen Themen haben wir bestimmt alles, was du brauchst! Weitere Informationen hier.
UnterstĂŒtzt Perlego Text-zu-Sprache?
Achte auf das Symbol zum Vorlesen in deinem nÀchsten Buch, um zu sehen, ob du es dir auch anhören kannst. Bei diesem Tool wird dir Text laut vorgelesen, wobei der Text beim Vorlesen auch grafisch hervorgehoben wird. Du kannst das Vorlesen jederzeit anhalten, beschleunigen und verlangsamen. Weitere Informationen hier.
Ist Clean Code in Python als Online-PDF/ePub verfĂŒgbar?
Ja, du hast Zugang zu Clean Code in Python von Mariano Anaya im PDF- und/oder ePub-Format sowie zu anderen beliebten BĂŒchern aus Computer Science & Programming in Python. Aus unserem Katalog stehen dir ĂŒber 1 Million BĂŒcher zur VerfĂŒgung.




Getting More Out of Our Objects with Descriptors

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.
Descriptors are another distinctive feature of Python that take object-oriented programming to another level, and their potential allows users to build more powerful and reusable abstractions. Most of the time, the full potential of descriptors is observed in libraries or frameworks.
In this chapter, we will achieve the following goals that relate to descriptors:
  • Understand what descriptors are, how they work, and how to implement them effectively
  • Analyze the two types of descriptors (data and non-data descriptors) in terms of their conceptual differences and implementation details
  • Reuse code effectively through descriptors
  • Analyze examples of good uses of descriptors, and how to take advantage of them for our API libraries

A first look at descriptors

First, we will explore the main idea behind descriptors to understand their mechanics and internal workings. Once this is clear, it will be easier to assimilate how the different types of descriptors work, which we will explore in the next section.
Once we have a general understanding of the idea behind descriptors, we will look at an example where their use gives us a cleaner and more Pythonic implementation.

The machinery behind descriptors

The way descriptors work is not all that complicated, but the problem with them is that there are a lot of caveats to take into consideration, so the implementation details are of the utmost importance here.
To implement descriptors, we need at least two classes. For this generic example, the client class will take advantage of the functionality we want to implement in the descriptor (this is generally just a domain model class, a regular abstraction we create for our solution), and the descriptor class will implement the logic of the descriptor itself.
A descriptor is, therefore, just an object that is an instance of a class that implements the descriptor protocol. This means that the interface of this class must contain at least one of the following magic methods (part of the descriptor protocol as of Python 3.6+):
  • __get__
  • __set__
  • __delete__
  • __set_name__
For the purposes of this initial high-level introduction, the following naming conventions will be used:
The domain-level abstraction that will take advantage of the functionality to be implemented by the descriptor. This class is said to be a client of the descriptor.
This class contains a class attribute (named descriptor by this convention), which is an instance of DescriptorClass.
The class that implements the descriptor itself. This class should implement some of the aforementioned magic methods that entail the descriptor protocol.
An instance of ClientClass.
client = ClientClass().
An instance of DescriptorClass.
descriptor = DescriptorClass().
This object is a class attribute that is placed in ClientClass.
Table 6.1: Descriptor naming conventions used in this chapter
This relationship is illustrated in Figure 6.1:
Picture 1
Figure 6.1: The relationship between ClientClass and DescriptorClass
A very important observation to keep in mind is that for this protocol to work, the descriptor object has to be defined as a class attribute. Creating this object as an instance attribute will not work, so it must be in the body of the class, and not in the __init__ method.
Always place the descriptor object as a class attribute!
On a slightly more critical note, readers can also note that it is possible to implement the descriptor protocol partially—not all methods must always be defined; instead, we can implement only those we need, as we will see shortly.
So, now we have the structure in place—we know what elements are set and how they interact. We need a class for the descriptor, another class that will consume the logic of the descriptor, which, in turn, will have a descriptor object (an instance of DescriptorClass) as a class attribute, and instances of ClientClass that will follow the descriptor protocol when we call for the attribute named descriptor. But now what? How does all of this fit into place at runtime?
Normally, when we have a regular class and we access its attributes, we simply obtain the objects as we expect them, and even their properties, as in the following example:
>>> class Attribute: ... value = 42 ... >>> class Client: ... attribute = Attribute() ... >>> Client().attribute <__main__.Attribute object at 0x...> >>> Client().attribute.value 42 
But, in the case of descriptors, something different happens. When an object is defined as a class attribute (and this one is a descriptor), when a client requests this attribute, instead of getting the object itself (as we would expect from the previous example), we get the result of having called the __get__ magic method.
Let's start with some simple code that only logs information about the context, and returns the same client object:
class DescriptorClass: def __get__(self, instance, owner): if instance is None: return self "Call: %s.__get__(%r, %r)", self.__class__.__name__, instance, owner ) return instance class ClientClass: descriptor = Descriptor...