book

Expert Python Programming - Fourth Edition

by Michał Jaworski, Tarek Ziade, Tarek Ziadé

May 2021

Intermediate to advanced

630 pages

15h 31m

English

Packt Publishing

Read now

Unlock full access

Who this book is forWhat this book coversTo get the most out of this bookGet in touch
Where are we now and where are we going?What to do with Python 2Keeping up to datePEP documentsActive communitiesOther resourcesSummary
Technical requirementsPython's packaging ecosystemInstalling Python packages using pipIsolating the runtime environmentApplication-level isolation versus system-level isolationApplication-level environment isolationPoetry as a dependency management systemSystem-level environment isolationContainerization versus virtualizationVirtual environments using DockerWriting your first DockerfileRunning containersSetting up complex environmentsUseful Docker and Docker Compose recipes for PythonVirtual development environments using VagrantPopular productivity toolsCustom Python shellsUsing IPythonIncorporating shells in your own scripts and programsInteractive debuggersOther productivity toolsSummary
Technical requirementsRecent language additionsDictionary merge and update operatorsAlternative – Dictionary unpackingAlternative – ChainMap from the collections moduleAssignment expressionsType-hinting genericsPositional-only parameterszoneinfo modulegraphlib moduleNot that new, but still shinybreakpoint() functionDevelopment modeModule-level __getattr__() and __dir__() functionsFormatting strings with f-stringsUnderscores in numeric literalssecrets moduleWhat may come in the future?Union types with the | operatorStructural pattern matchingSummary
Technical requirementsClass model and object-oriented programming Accessing super-classesMultiple inheritance and Method Resolution OrderClass instance initializationAttribute access patternsDescriptorsReal-life example – lazily evaluated attributesPropertiesDynamic polymorphismOperator overloadingDunder methods (language protocols)Comparison to C++Function and method overloadingSingle-dispatch functionsData classesFunctional programmingLambda functionsThe map(), filter(), and reduce() functionsPartial objects and partial functionsGeneratorsGenerator expressionsDecoratorsEnumerationsSummary
Technical requirementsInterfacesA bit of history: zope.interfaceUsing function annotations and abstract base classesUsing collections.abcInterfaces through type annotationsInversion of control and dependency injectionInversion of control in applicationsUsing dependency injection frameworksSummary
Technical requirementsWhat is concurrency?MultithreadingWhat is multithreading?How Python deals with threadsWhen should we use multithreading?Application responsivenessMultiuser applicationsWork delegation and background processingAn example of a multithreaded applicationUsing one thread per itemUsing a thread poolUsing two-way queuesDealing with errors in threadsThrottlingMultiprocessingThe built-in multiprocessing moduleUsing process poolsUsing multiprocessing.dummy as the multithreading interfaceAsynchronous programmingCooperative multitasking and asynchronous I/OPython async and await keywordsA practical example of asynchronous programmingIntegrating non-asynchronous code with async using futuresExecutors and futuresUsing executors in an event loopSummary
Technical requirementsWhat exactly is event-driven programming?Event-driven != asynchronousEvent-driven programming in GUIsEvent-driven communicationVarious styles of event-driven programmingCallback-based styleSubject-based styleTopic-based styleEvent-driven architecturesEvent and message queuesSummary
Technical requirementsWhat is metaprogramming?Using decorators to modify function behavior before use One step deeper: class decoratorsIntercepting the class instance creation processMetaclassesThe general syntaxMetaclass usageMetaclass pitfallsUsing the __init__subclass__() method as an alternative to metaclassesCode generationexec, eval, and compileThe abstract syntax tree Import hooksNotable examples of code generation in PythonFalcon's compiled routerHySummary
Technical requirementsC and C++ as the core of Python extensibilityCompiling and loading Python C extensionsThe need to use extensionsImproving performance in critical code sectionsIntegrating existing code written in different languagesIntegrating third-party dynamic librariesCreating efficient custom datatypesWriting extensionsPure C extensionsA closer look at the Python/C APICalling and binding conventionsException handlingReleasing GILReference countingWriting extensions with CythonCython as a source-to-source compilerCython as a languageDownsides of using extensionsAdditional complexityHarder debuggingInterfacing with dynamic libraries without extensionsThe ctypes moduleLoading librariesCalling C functions using ctypesPassing Python functions as C callbacksCFFISummary

Technical requirementsThe principles of test-driven developmentWriting tests with pytestTest parameterizationpytest's fixturesUsing fakesMocks and the unittest.mock moduleQuality automationTest coverageStyle fixers and code lintersStatic type analysisMutation testingUseful testing utilitiesFaking realistic data valuesFaking time valuesSummary
Technical requirementsPackaging and distributing librariesThe anatomy of a Python packagesetup.pysetup.cfgMANIFEST.inEssential package metadataTrove classifiersTypes of package distributionssdist distributionsbdist and wheel distributionsRegistering and publishing packagesPackage versioning and dependency managementThe SemVer standard for semantic versioningCalVer for calendar versioningInstalling your own packagesInstalling packages directly from sourcesInstalling packages in editable modeNamespace packagesPackage scripts and entry pointsPackaging applications and services for the webThe Twelve-Factor App manifestoLeveraging DockerHandling environment variablesThe role of environment variables in application frameworksCreating standalone executablesWhen standalone executables are usefulPopular toolsPyInstallercx_Freezepy2exe and py2appSecurity of Python code in executable packagesSummary
Technical requirementsCapturing errors and logsPython logging essentialsLogging system componentsLogging configurationGood logging practicesDistributed loggingCapturing errors for later reviewInstrumenting code with custom metricsUsing PrometheusDistributed application tracingDistributed tracing with JaegerSummary
Technical requirementsCommon culprits for bad performanceCode complexityCyclomatic complexityThe big O notationExcessive resource allocation and leaksExcessive I/O and blocking operationsCode profilingProfiling CPU usageMacro-profilingMicro-profilingProfiling memory usageUsing the objgraph moduleC code memory leaksReducing complexity by choosing appropriate data structuresSearching in a listUsing setsUsing the collections moduledequedefaultdictnamedtupleLeveraging architectural trade-offsUsing heuristics and approximation algorithmsUsing task queues and delayed processingUsing probabilistic data structuresCachingDeterministic cachingNon-deterministic cachingSummary

Overview

Dive into the advanced world of Python with 'Expert Python Programming - Fourth Edition'. This comprehensive guide takes you through mastering Python's latest features, coding practices, and essential tools, all designed to optimize your programming experience and elevate your skillset.

What this Book will help me do

Master the newest features in Python including structural pattern matching and dictionary merges.
Develop scalable applications using advanced programming techniques like concurrency and event-driven systems.
Enhance your Python development by learning how to integrate and extend Python with C and C++.
Leverage modern methodologies for setting up Python environments that suit diverse deployment scenarios.
Automate builds and testing processes to maintain robust and high-quality Python applications.

Author(s)

Michał Jaworski and Tarek Ziadé bring years of Python development expertise to the table. Michał has worked extensively in crafting solutions using Python at various scales, while Tarek is widely recognized for his contributions to the Python community as a speaker and author. They share a passion for Python's elegance and empower developers through clear and structured guidance.

Who is it for?

This book is tailored for experienced software developers who are eager to deepen their expertise in Python. If you have a solid grounding in programming and a fundamental understanding of Python basics, this book will refine your skills and introduce you to Python's advanced features. It's particularly useful for programmers transitioning from Python 2 to Python 3.9 or newer, and will greatly benefit developers aiming to master Python for robust application development.