book

Clean Code in Python - Second Edition

by Mariano Anaya

January 2021

Intermediate to advanced

422 pages

10h 39m

English

Packt Publishing

Read now

Unlock full access

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
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
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
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 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
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
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
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
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
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

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

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: