book

Learning Python Application Development

Name: Learning Python Application Development
Author: Ninad Sathaye
ISBN: 9781785889196

by Ninad Sathaye

September 2016

Intermediate to advanced

454 pages

9h 23m

English

Packt Publishing

Read now

Unlock full access

Learning Python Application Development
Table of Contents
Learning Python Application Development
Credits
Disclaimers
About the Author
About the Reviewer
www.PacktPub.com
eBooks, discount offers, and moreWhy subscribe?
Preface
Important things to note
Very important note for e-book readers

What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
Downloading the example codeDownloading the color images of this bookErrataPiracyQuestions
1. Developing Simple Applications
Important housekeeping notes
Installation prerequisites
Installing PythonOption 1 – official distributionOption 2 – bundled distributionPython install locationUnix-like operating systemsWindows OSVerifying Python installationInstalling pipInstalling IPythonChoosing an IDE
The theme of the book
Meet the characters
Simple script – Attack of the Orcs v0.0.1
The game – Attack of the Orcs v0.0.1Problem statementPseudo code – version 0.0.1Reviewing the codeRunning Attack of the Orcs v0.0.1
Using functions – Attack of the Orcs v0.0.5
Revisiting the previous versionPseudo code with attack feature – Version 0.0.5Reviewing the codeRunning Attack of the Orcs v0.0.5
Using OOP – Attack of the Orcs v1.0.0
Prioritize the feature requestsProblem statementRedesigning the codePainting the big picturePseudo UML representationUnderstanding the pseudo UML diagramReviewing the codeRunning Attack of the Orcs v1.0.0
Abstract base classes in Python
Exercise
Summary
Very important note for e-book readers
2. Dealing with Exceptions
Revisiting Attack of the Orcs v1.0.0Debugging the problemFixing the bugs…
Exceptions
What is an exception?Most common exceptionsException handlingRaising and re-raising an exceptionThe else block of try…exceptfinally...clean it up!
Back to the game – Attack of the Orcs v1.1.0
Preparatory workAdding the exception handling codeRunning Attack of the Orcs v1.1.0
Defining custom exceptions
Preparatory workCustom exception – The problemWriting a new exception classExpanding the exception classInheriting from the exception class
Exercise
Summary
3. Modularize, Package, Deploy!
Selecting a versioning conventionSerial incrementsUsing a date formatSemantic versioning scheme
Modularizing the code
Attack of the Orcs v2.0.0
Creating a package
Importing from the package
Releasing the package on PyPI
Prepare the distributionStep 1 – Setting up the package directoryStep 2 – Writing the setup.py fileStep 3 – Updating the README and LICENSE.txt filesStep 4 – Updating the MANIFEST.in fileStep 5 – Build a deployment-ready distributionUploading the distributionStep 1 – Creating an account on PyPI test websiteStep 2 – Creating a .pypirc fileStep 3 – Register your projectStep 4 – Uploading the packageA single command to do it allInstalling your own distribution
Using a private PyPI repository
Step 1 – Installing pypiserverStep 2 – Building a new source distributionStep 3 – Starting a local serverStep 4 – Installing the private distribution
Making an incremental release
Packaging and uploading the new versionUpgrading the installed version
Version controlling the code
Git resourcesInstalling GitConfiguring your identityBasic Git terminologyCreating and using a Git repositoryCreating a bare remote repositoryClone the repositoryCopying the code to the cloned repositoryStaging the code and committingPushing the changes to the central repository
Using GUI clients for Git
Exercise
Summary
4. Documentation and Best Practices
Documenting the codeDocstringsIntroduction to reStructuredTextSection headingsParagraphsText stylesCode snippetsMathematical equationsBullets and numberingDosctrings using RSTDocstring formatting stylesAutomatically creating docstring stubsGenerating documentation with SphinxStep 1 – Installing Sphinx using pipStep 2 – cd to the source directoryStep 3 – Running sphinx-quickstartStep 4 – Updating conf.pyStep 5 – Running sphinx-apidocStep 6 – Building the documentationUsing sphinx-buildUsing Makefile
Python coding standards
Code analysis – How well are we doing?
Code analysis using IDEPylintPylint in actionPEP8 and AutoPEP8
Exercise
Summary
5. Unit Testing and Refactoring
This is how the chapter is organizedImportant housekeeping notes
Why test?
A new feature was requestedYou implemented this featureBut something wasn't right...It required thorough testing
Unit testing
Python unittest frameworkBasic terminologyCreating tests with unittest.TestCaseControlling test executionUsing unittest.TestSuite
Writing unit tests for the application
Setting up a test packageCreating a new class for unit testingFirst unit test – Injured unit selectionRunning the first unit testSecond unit test – Acquiring the hutRunning only the second testCreating individual test modulesBatch executing unit tests
Unit tests using mock library
Quick introduction to mockLet's mock!Using Mock objects in a unit testWorking with patchesUsing patch in a unit testThird unit test – The play method
Is your code covered?
Resolving import errors, if any
Other unit testing tools
DoctestNosePytest
Refactoring preamble
Take a detour – Refactor for testability
Refactoring
What is refactoring?Why refactor?When to refactor?How to refactor?RenamingExtractingMovingPushing downPulling upRefactoring tools for Python
Unit testing revisited
Refactoring for testabilityFourth unit test – setup_game_scenario
Exercise
Refactoring and redesign exercise
Summary
6. Design Patterns
Introduction to design patternsClassification of patternsBehavioral patternsCreational patternsStructural patternsConcurrency patterns
Python language and design patterns
First-class functionsClasses as first-class objectsClosuresMiscellaneous featuresClass methodAbstract methodThe __getattr__ methodDuck typing
Structure of the rest of the chapter
Fast forward – Attack of the Orcs v6.0.0
Strategy pattern
Strategy scenario – The jump featureStrategy – The problemStrategy – Attempted solutionStrategy – Rethinking the designStrategy solution 1 – Traditional approachStrategy solution 2 – Pythonic approach
Simple factory
Simple factory scenario – The recruit featureSimple factory – The problemSimple factory – Rethinking the designSimple factory solution 1 – Traditional approachSimple factory solution 2 – Pythonic approach
Abstract factory pattern
Abstract factory scenario – An accessory storeAbstract factory – The problemAbstract factory – Rethinking the designSimplifying the design furtherAbstract factory solution – Pythonic approachAdvanced topic – enforcing an interface
Adapter pattern
Adapter scenario – Elf's distant cousinAdapter – The problemAdapter – Attempted solutionAdapter solution – Pythonic approachAdapter – Multiple adapter methods
Summary
7. Performance – Identifying Bottlenecks
Overview of three performance chaptersMore focus on the runtime performanceThe first performance chapterThe second performance chapterThe third performance chapterSneak peek at the upcoming application speedup
Scenario – The Gold Hunt
High-level algorithmReviewing the initial codeRunning the code
The problem
Identifying the bottlenecks
Measuring the execution timeMeasuring the runtime of small code snippetsCode profilingThe cProfile moduleThe pstats moduleThe line_profiler package
Memory profiling
The memory_profiler package
Algorithm efficiency and complexity
Algorithm efficiencyAlgorithm complexity
Big O notation
Big O complexity classesO(1) – constant timeO(log n) – logarithmicO(n) – Linear timeO(n log n) – Log linearO(n2) – QuadraticO(n3) – cubicUpper bound of the complexityComplexity for common data structures and algorithmsWrapping up the big O discussion
Summary
8. Improving Performance – Part One
Prerequisite for the chapter
This is how the chapter is organized
Revisiting the Gold Hunt scenario
Selecting a problem sizeProfiling the initial code
Optimizing Gold Hunt – Part one
Tweaking the algorithm – The square rootGold Hunt optimization – Pass oneSkipping the dotsGold Hunt optimization – Pass twoUsing local scopeGold Hunt optimization – Pass three
Performance improvement goodies
List comprehensionRecording execution timeDictionary comprehensionSwapping conditional block and for loops'try' it out in a loopChoosing the right data structuresThe collections moduleThe deque classThe defaultdict classGenerators and generator expressionsGenerator expressionsComparing the memory efficiencyGenerator expressions or list comprehensions?The itertools moduleThe itertools.chain iterator
Exercises
Summary
9. Improving Performance – Part Two, NumPy and Parallelization
Prerequisites for this chapter
This is how the chapter is organized
Introduction to NumPy
Installing NumPyCreating array objectsSimple array operationsArray slicing and indexingIndexingSlicingBroadcastingMiscellaneous functionsnumpy.ndarray.tolistnumpy.reshapenumpy.randomnumpy.dstacknumpy.einsumComputing distance square with einsumWhere to get more information on NumPy?
Optimizing Gold Hunt – Part two
Gold Hunt optimization – pass fourGold Hunt optimization – pass five
Parallelization with the multiprocessing module
Introduction to parallelizationShared memory parallelizationDistributed memory parallelizationGlobal interpreter lockThe multiprocessing moduleThe Pool class
Parallelizing the Gold Hunt program
Revisiting the gold fieldGold Hunt optimization – Pass six, parallelizationOther methods for parallelization
Further reading
JIT compilersGPU accelerated computing
Summary
10. Simple GUI Applications
Overview of GUI frameworksTkinterPyQtPySideKivywxPython
GUI programming design considerations
Understanding user requirementsDeveloping a user storySimplicity and accessibilityConsistencyPredictability and familiarityMiscellaneous design considerations
Event-driven programming
EventEvent handlingEvent loop
GUI programming with Tkinter
Tkinter documentation linksThe mainloop() in TkinterSimple GUI application – Take 1Simple GUI application – Take 2GUI Widgets in TkinterGeometry managementGrid geometry managerPack geometry managerPlace geometry managerEvents in TkinterEvent typesEvent descriptorsEvent object attributesEvent handling in TkinterCommand callback (Button widget)The bind() methodThe bind_class() methodThe bind_all() method
Project-1 – Attack of the Orcs V10.0.0
Background scenarioProblem statementWriting the codeOverview of the class HutGameThe __init__ methodThe occupy_huts methodThe create_widgets methodThe setup_layout methodThe radio_btn_pressed and enter_hut methodsThe announce_winner methodRunning the application
MVC architecture
ModelViewControllerAdvantages of MVC
Project 2 – Attack of the Orcs v10.1.0
Revisiting the HutGame classCreating MVC classesCommunication between MVC objectsController to Model or View communicationModel to Controller communicationUsing method assignmentUsing a publish-subscribe patternPyPubSub packageView to Controller communicationCommunication between View and ModelReviewing the codeThe Controller classThe Model classThe View classRunning the application
Testing GUI applications
Testing considerationsUnit testing and MVCManual testingAutomated GUI testing
Exercises
Further reading
Summary
Index