Learning Python Application Development

Cover
Copyright
Credits
Disclaimers
About the Author
About the Reviewer
www.PacktPub.com
Table of Contents
Preface
Chapter 1: Developing Simple Applications
	Important housekeeping notes
	Installation prerequisites
		Installing Python
			Option 1 – official distribution
			Option 2 – bundled distribution
			Python install location
			Verifying Python installation
			Installing pip
			Installing IPython
			Choosing 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.1
		Problem statement
		Pseudo code – version 0.0.1
		Reviewing the code
		Running Attack of the Orcs v0.0.1
		Revisiting the previous version
		Pseudo code with attack feature – Version 0.0.5
		Reviewing the code
		Running Attack of the Orcs v0.0.5
	Using OOP – Attack of the Orcs v1.0.0
		Prioritize the feature requests
		Problem statement
		Redesigning the code
		Painting the big picture
			Pseudo UML representation
			Understanding the pseudo UML diagram
		Reviewing the code
		Running Attack of the Orcs v1.0.0
	Abstract base classes in Python
		Exercise
	Summary
		Very important note for e-book readers
Chapter 2: Dealing with Exceptions
	Revisiting Attack of the Orcs v1.0.0
		Debugging the problem
		Fixing the bugs…
	Exceptions
		What is an exception?
		Most common exceptions
		Exception handling
		Raising and re-raising an exception
		The else block of try…except
		finally...clean it up!
	Back to the game – Attack of the Orcs v1.1.0
		Preparatory work
		Adding the exception handling code
		Running Attack of the Orcs v1.1.0
	Defining custom exceptions
		Preparatory work
		Custom exception – The problem
		Writing a new exception class
		Expanding the exception class
		Inheriting from the exception class
	Exercise
Chapter 3: Modularize, Package, Deploy!
	Selecting a versioning convention
		Serial increments
		Using a date format
		Semantic 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 distribution
			Step 1 – Setting up the package directory
			Step 2 – Writing the setup.py file
			Step 3 – Updating the README and LICENSE.txt files
			Step 4 – Updating the MANIFEST.in file
			Step 5 – Build a deployment-ready distribution
		Uploading the distribution
			Step 1 – Creating an account on PyPI test website
			Step 2 – Creating a .pypirc file
			Step 3 – Register your project
			Step 4 – Uploading the package
		A single command to do it all
		Installing your own distribution
	Using a private PyPI repository
		Step 1 – Installing pypiserver
		Step 2 – Building a new source distribution
		Step 3 – Starting a local server
		Step 4 – Installing the private distribution
	Making an incremental release
		Packaging and uploading the new version
		Upgrading the installed version
	Version controlling the code
		Git resources
		Installing Git
		Configuring your identity
		Basic Git terminology
		Creating and using a Git repository
			Creating a bare remote repository
			Clone the repository
			Copying the code to the cloned repository
			Staging the code and committing
			Pushing the changes to the central repository
	Using GUI clients for Git
	Exercise
	Summary
Chapter 4: Documentation and Best Practices
	Documenting the code
		Docstrings
		Introduction to reStructuredText
			Section headings
			Paragraphs
			Text styles
			Code snippets
			Mathematical equations
			Bullets and numbering
		Dosctrings using RST
		Docstring formatting styles
		Automatically creating docstring stubs
		Generating documentation with Sphinx
			Step 1 – Installing Sphinx using pip
			Step 2 – cd to the source directory
			Step 3 – Running sphinx-quickstart
			Step 4 – Updating conf.py
			Step 5 – Running sphinx-apidoc
			Step 6 – Building the documentation
	Python coding standards
	Code analysis – How well are we doing?
		Code analysis using IDE
		Pylint
			Pylint in action
			PEP8 and AutoPEP8
	Exercise
	Summary
Chapter 5: Unit Testing and Refactoring
	This is how the chapter is organized
		Important housekeeping notes
	Why test?
		A new feature was requested
		You implemented this feature
		But something wasn't right...
		It required thorough testing
	Unit testing
		Python unittest framework
			Basic terminology
			Creating tests with unittest.TestCase
			Controlling test execution
			Using unittest.TestSuite
	Writing unit tests for the application
		Setting up a test package
		Creating a new class for unit testing
		First unit test – Injured unit selection
		Running the first unit test
		Second unit test – Acquiring the hut
			Running only the second test
		Creating individual test modules
		Batch executing unit tests
	Unit tests using mock library
		Quick introduction to mock
		Let's mock!
		Using Mock objects in a unit test
		Working with patches
			Using patch in a unit test
		Third unit test – The play method
	Is your code covered?
		Resolving import errors, if any
	Other unit testing tools
		Doctest
		Nose
		Pytest
	Refactoring preamble
		Take a detour – Refactor for testability
	Refactoring
		What is refactoring?
		Why refactor?
		When to refactor?
		How to refactor?
			Renaming
			Extracting
		Moving
			Pushing down
			Pulling up
			Refactoring tools for Python
	Unit testing revisited
		Refactoring for testability
		Fourth unit test – setup_game_scenario
	Exercise
		Refactoring and redesign exercise
	Summary
Chapter 6: Design Patterns
	Introduction to design patterns
		Classification of patterns
			Behavioral patterns
			Creational patterns
			Structural patterns
			Concurrency patterns
	Python language and design patterns
		First-class functions
		Classes as first-class objects
		Closures
		Miscellaneous features
			Class method
			Abstract method
			The __getattr__ method
		Duck typing
	Structure of the rest of the chapter
	Fast forward – Attack of the Orcs v6.0.0
	Strategy pattern
		Strategy scenario – The jump feature
		Strategy – The problem
		Strategy – Attempted solution
		Strategy – Rethinking the design
		Strategy solution 1 – Traditional approach
		Strategy solution 2 – Pythonic approach
	Simple factory
		Simple factory scenario – The recruit feature
		Simple factory – The problem
		Simple factory – Rethinking the design
		Simple factory solution 1 – Traditional approach
		Simple factory solution 2 – Pythonic approach
	Abstract factory pattern
		Abstract factory scenario – An accessory store
		Abstract factory – The problem
		Abstract factory – Rethinking the design
			Simplifying the design further
		Abstract factory solution – Pythonic approach
			Advanced topic – enforcing an interface
	Adapter pattern
		Adapter scenario – Elf's distant cousin
		Adapter – The problem
		Adapter – Attempted solution
		Adapter solution – Pythonic approach
			Adapter – Multiple adapter methods
	Summary
Chapter 7: Performance – Identifying Bottlenecks
	Overview of three performance chapters
		More focus on the runtime performance
		The first performance chapter
		The second performance chapter
		The third performance chapter
		Sneak peek at the upcoming application speedup
	Scenario – The Gold Hunt
		High-level algorithm
		Reviewing the initial code
		Running the code
	The problem
	Identifying the bottlenecks
		Measuring the execution time
		Measuring the runtime of small code snippets
		Code profiling
			The cProfile module
			The pstats module
			The line_profiler package
	Memory profiling
		The memory_profiler package
	Algorithm efficiency and complexity
		Algorithm efficiency
		Algorithm complexity
	Big O notation
		Big O complexity classes
			O(1) – constant time
			O(log n) – logarithmic
			O(n) – Linear time
			O(n log n) – Log linear
			O(n2) – Quadratic
			O(n3) – cubic
			Upper bound of the complexity
			Complexity for common data structures and algorithms
			Wrapping up the big O discussion
	Summary
Chapter 8: Improving Performance – Part One
	Prerequisite for the chapter
	This is how the chapter is organized
	Revisiting the Gold Hunt scenario
		Selecting a problem size
		Profiling the initial code
	Optimizing Gold Hunt – Part one
		Tweaking the algorithm – The square root
			Gold Hunt optimization – Pass one
		Skipping the dots
			Gold Hunt optimization – Pass two
		Using local scope
			Gold Hunt optimization – Pass three
	Performance improvement goodies
		List comprehension
		Recording execution time
		Dictionary comprehension
		Swapping conditional block and for loops
		'try' it out in a loop
		Choosing the right data structures
		The collections module
			The deque class
			The defaultdict class
		Generators and generator expressions
			Generator expressions
			Comparing the memory efficiency
			Generator expressions or list comprehensions?
		The itertools module
			The itertools.chain iterator
	Exercises
	Summary
Chapter 9: Improving Performance – Part Two, NumPy and Parallelization
	Prerequisites for this chapter
	This is how the chapter is organized
	Introduction to NumPy
		Installing NumPy
		Creating array objects
		Simple array operations
		Array slicing and indexing
			Indexing
			Slicing
		Broadcasting
		Miscellaneous functions
			numpy.ndarray.tolist
			numpy.reshape
			numpy.random
			numpy.dstack
			numpy.einsum
			Computing distance square with einsum
		Where to get more information on NumPy?
	Optimizing Gold Hunt – Part two
		Gold Hunt optimization – pass four
		Gold Hunt optimization – pass five
	Parallelization with the multiprocessing module
		Introduction to parallelization
			Shared memory parallelization
			Distributed memory parallelization
		Global interpreter lock
		The multiprocessing module
			The Pool class
	Parallelizing the Gold Hunt program
		Revisiting the gold field
		Gold Hunt optimization – Pass six, parallelization
			Other methods for parallelization
	Further reading
		JIT compilers
			GPU accelerated computing
	Summary
Chapter 10: Simple GUI Applications
	Overview of GUI frameworks
		Tkinter
		PyQt
		PySide
		Kivy
		wxPython
	GUI programming design considerations
		Understanding user requirements
		Developing a user story
		Simplicity and accessibility
		Consistency
		Predictability and familiarity
		Miscellaneous design considerations
	Event-driven programming
		Event
		Event handling
		Event loop
	GUI programming with Tkinter
		Tkinter documentation links
		The mainloop() in Tkinter
		Simple GUI application – Take 1
		Simple GUI application – Take 2
		GUI Widgets in Tkinter
		Geometry management
			Grid geometry manager
			Pack geometry manager
			Place geometry manager
		Events in Tkinter
			Event types
			Event descriptors
			Event object attributes
		Event handling in Tkinter
			Command callback (Button widget)
			The bind() method
			The bind_class() method
			The bind_all() method
	Project-1 – Attack of the Orcs V10.0.0
		Background scenario
		Problem statement
		Writing the code
			Overview of the class HutGame
			The __init__ method
			The occupy_huts method
			The create_widgets method
			The setup_layout method
			The radio_btn_pressed and enter_hut methods
			The announce_winner method
		Running the application
	MVC architecture
		Model
		View
		Controller
		Advantages of MVC
	Project 2 – Attack of the Orcs v10.1.0
		Revisiting the HutGame class
		Creating MVC classes
		Communication between MVC objects
			Controller to Model or View communication
			Model to Controller communication
			View to Controller communication
			Communication between View and Model
		Reviewing the code
			The Controller class
		The Model class
		The View class
		Running the application
	Testing GUI applications
		Testing considerations
			Unit testing and MVC
			Manual testing
			Automated GUI testing
	Exercises
	Further reading
	Summary
Index