book

Clean Code in Python - Second Edition

Name: Clean Code in Python - Second Edition
Author: Mariano Anaya
ISBN: 9781800560215

by Mariano Anaya

January 2021

Intermediate to advanced

422 pages

10h 39m

English

Packt Publishing

Read now

Unlock full access

Preface
Who this book is for?What this book coversTo get the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchReviews
Introduction, Code Formatting, and Tools
IntroductionThe meaning of clean codeThe importance of having clean codeSome exceptionsCode formattingAdhering to a coding style guide on your projectDocumentationCode commentsDocstringsAnnotationsDo annotations replace docstrings?ToolingChecking type consistencyGeneric validations in codeAutomatic formattingSetup for automatic checksSummaryReferences
Pythonic Code
Indexes and slicesCreating your own sequencesContext managersImplementing context managersComprehensions and assignment expressionsProperties, attributes, and different types of methods for objectsUnderscores in PythonPropertiesCreating classes with a more compact syntaxIterable objectsCreating iterable objectsCreating sequencesContainer objectsDynamic attributes for objectsCallable objectsSummary of magic methodsCaveats in PythonMutable default argumentsExtending built-in typesA brief introduction to asynchronous codeSummaryReferences
General Traits of Good Code
Design by contractPreconditionsPostconditionsPythonic contractsDesign by contract – conclusionsDefensive programmingError handlingValue substitutionException handlingUsing assertions in PythonSeparation of concernsCohesion and couplingAcronyms to live byDRY/OAOOYAGNIKISEAFP/LBYLInheritance in PythonWhen inheritance is a good decisionAnti-patterns for inheritanceMultiple inheritance in PythonMethod Resolution Order (MRO)MixinsArguments in functions and methodsHow function arguments work in PythonHow arguments are copied to functionsVariable number of argumentsPositional-only parametersKeyword-only argumentsThe number of arguments in functionsFunction arguments and couplingCompact function signatures that take too many argumentsFinal remarks on good practices for software designOrthogonality in softwareStructuring the codeSummaryReferences
The SOLID Principles
The single responsibility principleA class with too many responsibilitiesDistributing responsibilitiesThe open/closed principleExample of maintainability perils for not following the OCPRefactoring the events system for extensibilityExtending the events systemFinal thoughts about the OCPLiskov's substitution principleDetecting LSP issues with toolsUsing mypy to detect incorrect method signaturesDetecting incompatible signatures with pylintMore subtle cases of LSP violationsRemarks on the LSPInterface segregationAn interface that provides too muchThe smaller the interface, the betterHow small should an interface be?Dependency inversionA case of rigid dependenciesInverting the dependenciesDependency injectionSummaryReferences
Using Decorators to Improve Our Code
What are decorators in Python?Function decoratorsDecorators for classesOther types of decoratorMore advanced decoratorsPassing arguments to decoratorsDecorators with nested functionsDecorator objectsDecorators with default valuesDecorators for coroutinesExtended syntax for decoratorsGood uses for decoratorsAdapting function signaturesValidating parametersTracing codeEffective decorators – avoiding common mistakesPreserving data about the original wrapped objectDealing with side effects in decoratorsIncorrect handling of side effects in a decoratorRequiring decorators with side effectsCreating decorators that will always workDecorators and clean codeComposition over inheritanceThe DRY principle with decoratorsDecorators and separation of concernsAnalysis of good decoratorsSummaryReferences
Getting More Out of Our Objects with Descriptors
A first look at descriptorsThe machinery behind descriptorsExploring each method of the descriptor protocolThe get methodThe set methodThe delete methodThe set name methodTypes of descriptorsNon-data descriptorsData descriptorsDescriptors in actionAn application of descriptorsA first attempt without using descriptorsThe idiomatic implementationDifferent forms of implementing descriptorsThe issue of shared stateAccessing the dictionary of the objectUsing weak referencesMore considerations about descriptorsReusing codeAn alternative to class decoratorsAnalysis of descriptorsHow Python uses descriptors internallyFunctions and methodsBuilt-in decorators for methodsSlotsImplementing descriptors in decoratorsFinal remarks about descriptorsInterface of descriptorsObject-oriented design of the descriptorsType annotations on descriptorsSummaryReferences
Generators, Iterators, and Asynchronous Programming
Technical requirementsCreating generatorsA first look at generatorsGenerator expressionsIterating idiomaticallyIdioms for iterationThe next() functionUsing a generatorItertoolsSimplifying code through iteratorsThe iterator pattern in PythonCoroutinesThe methods of the generator interfaceclose()throw(ex_type[, ex_value[, ex_traceback]])send(value)More advanced coroutinesReturning values in coroutinesDelegating into smaller coroutines – the 'yield from' syntaxAsynchronous programmingMagic asynchronous methodsAsynchronous context managersOther magic methodsAsynchronous iterationAsynchronous generatorsSummaryReferences
Unit Testing and Refactoring
Design principles and unit testingA note about other forms of automated testingUnit testing and agile software developmentUnit testing and software designDefining the boundaries of what to testTools for testingFrameworks and libraries for unit testingunittestpytestCode coverageMock objectsRefactoringEvolving our codeProduction code isn't the only one that evolvesMore about testingProperty-based testingMutation testingCommon themes in testingBoundaries or limit valuesClasses of equivalenceEdge casesA brief introduction to test-driven developmentSummaryReferences
Common Design Patterns
Design pattern considerations in PythonDesign patterns in actionCreational patternsFactoriesSingleton and shared state (monostate)BuilderStructural patternsAdapterCompositeDecoratorFacadeBehavioral patternsChain of responsibilityThe template methodCommandStateThe null object patternFinal thoughts about design patternsThe influence of patterns over the designDesign patterns as theoryNames in our modelsSummaryReferences

Clean Architecture
From clean code to clean architectureSeparation of concernsMonolithic applications and microservicesAbstractionsSoftware componentsPackagesManaging dependenciesOther considerations when managing dependenciesArtifact versionsDocker containersUse caseThe codeDomain modelsCalling from the applicationAdaptersThe servicesAnalysisThe dependency flowLimitationsTestabilityIntention revealingSummaryReferencesSumming it all up
Other Books You May Enjoy
Index

Content preview from Clean Code in Python - Second Edition

10 Clean Architecture

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.

The main goals of this chapter are as follows:

Designing software systems that can be maintained in the long run
Working effectively on a software project by maintaining quality attributes
Studying how all concepts applied to code relate to systems in general

This chapter explores how clean code evolves ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781800560215

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Clean Code in Python - Second Edition

by Mariano Anaya

10

Clean Architecture

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.