Practices of the Python Pro
Dane Hillard
  • MEAP began January 2019
  • Publication in January 2020 (estimated)
  • ISBN 9781617296086
  • 305 pages (estimated)
  • printed in black & white

Exactly what the Python world needs.

Patrick Regan
Professional developers know the many benefits of writing application code that’s clean, well-organized, and easy to maintain. By learning and following established patterns and best practices, you can take your code and your career to a new level. With Practices of the Python Pro, you’ll learn to design professional-level, clean, easily-maintainable software at scale using the incredibly popular programming language, Python. You’ll find easy-to-grok examples that use pseudocode and Python to introduce software development best practices, along with dozens of instantly-useful techniques that will help you code like a pro.
Table of Contents detailed table of contents

Part 1: Why it all matters

1 The bigger picture

1.1 Python is an enterprise language

1.1.1 The times they are a-changin'

1.1.2 What I like about Python

1.2 Python is a teaching language

1.3 Design is a process

1.3.1 The user experience

1.3.2 You’ve been here before

1.4 Design enables better software

1.4.1 Considerations in software design

1.4.2 Organically-grown software

1.5 When to invest in design

1.6 New beginnings

1.7 Design is democratic

1.7.1 Presence of mind

1.8 Summary

Part 2: Foundations of design

2 Separation of concerns

2.1 Namespacing

2.1.1 Namespaces and the import statement

2.1.2 The many masks of importing

2.1.3 Namespaces prevent collisions

2.2 The hierarchy of separation in Python

2.2.1 Functions

2.2.2 Classes

2.2.3 Modules

2.2.4 Packages

2.3 Summary

3 Abstraction and Encapsulation

3.1 What is abstraction?

3.1.1 The "black box"

3.1.2 Abstraction is like an onion

3.1.3 Abstraction is a simplifier

3.1.4 Decomposition enables abstraction

3.2 Encapsulation

3.2.1 Encapsulation constructs in Python

3.2.2 Expectations of privacy in Python

3.3 Try it out

3.3.1 Refactoring

3.4 Programming styles are an abstraction, too!

3.4.1 Procedural programming

3.4.2 Functional programming

3.4.3 Declarative programming

3.5 Typing, inheritance, and polymorphism

3.6 Recognizing the wrong abstraction

3.6.1 Square pegs in round holes

3.6.2 Clever gets the cleaver

3.7 Summary

4 Designing for high performance

4.1 Hurtling through time and space

4.1.1 Complexity is a little�complex

4.1.2 Time complexity

4.1.3 Space complexity

4.2 Performance and data types

4.2.1 Data types for constant time

4.2.2 Data types for linear time

4.2.3 Space complexity of operations on data types

4.3 Make it work, make it right, make it fast

4.3.1 Making it work

4.3.2 Making it right

4.3.3 Making it fast

4.4 Tools

4.4.1 timeit

4.4.2 CPU profiling

4.5 Try it out

4.6 Summary

5 Testing your software

5.1 What is software testing?

5.1.1 Does it do what it says on the tin?

5.1.2 The anatomy of a functional test

5.2 Functional testing approaches

5.2.1 Manual testing

5.2.2 Automated testing

5.2.3 Acceptance testing

5.2.4 Unit testing

5.2.5 Integration testing

5.2.6 The testing pyramid

5.2.7 Regression testing

5.3 Statements of fact

5.4 Unit testing with unittest

5.4.1 Test organization with unittest

5.4.2 Running tests with unittest

5.4.3 Writing your first test with unittest

5.4.4 Writing your first integration test with unittest

5.4.5 Test doubles

5.4.6 Try it out

5.4.7 Writing interesting tests

5.5 Testing with pytest

5.5.1 Test organization with pytest

5.5.2 Converting unittest tests to pytest

5.6 Beyond functional testing

5.6.1 Performance testing

5.6.2 Load testing

5.7 Test-driven development: a primer

5.7.1 It’s a mindset

5.7.2 It’s a philosophy

5.8 Summary

Part 3: Nailing down large systems

6 Separation of Concerns in Practice

6.1 A command-line bookmarking application

6.2 A tour of Bark

6.2.1 The benefits of separation: reprise

6.3 An initial code structure, by concern

6.3.1 The persistence layer

6.3.2 The business logic layer

6.3.3 The presentation layer

6.4 Summary

7 Extensibility and Flexibility

7.1 What is extensible code?

7.1.1 Adding new behaviors

7.1.2 Modifying existing behaviors

7.1.3 Loose coupling

7.2 Solutions for rigidity

7.2.1 Letting go: inversion of control

7.2.2 The devil’s in the details: relying on interfaces

7.2.3 Fighting entropy: the robustness principle

7.3 An exercise in extension

7.4 Summary

8 The Rules (and Exceptions) of Inheritance

8.1 The inheritance of programming past

8.1.1 The silver bullet

8.1.2 The challenges of hierarchies

8.2 The inheritance of programming present

8.2.1 What is inheritance for, really?

8.2.2 Substitutability

8.2.3 The ideal use case for inheritance

8.3 Inheritance in Python

8.3.1 Type inspection

8.3.2 Superclass access

8.3.3 Multiple inheritance and method resolution order

8.3.4 Abstract base classes

8.4 Inheritance and composition in Bark

8.4.1 Refactoring to use an abstract base class

8.4.2 A final check on your inheritance work

8.5 Summary

9 Keeping things lightweight

10 Achieving loose coupling

Part 4: What’s Next?

11 Onward and upward


Appendix A: Installing Python

A.1 What version of Python should I use?

A.2 The "system" Python

A.3 Installing other versions of Python

A.3.1 Download the official Python

A.3.2 Download using Anaconda

A.4 Verifying the installation

About the Technology

No matter what language you choose, your applications need to be understandable and easily maintainable by yourself and other team members. To hit this mark, you need to follow industry-standard best practices for coding style, application design, and development process. That’s exactly what you’ll learn in Practices of the Python Pro! The code examples in this book use Python, which is both a great development language and a fantastic teaching tool.

About the book

Practices of the Python Pro teaches you to design and write software that’s easy to understand, maintain, and scale. Using practical Python-based examples, experienced developer Dane Hillard introduces design concepts that lay the foundation for designing, building, and maintaining software that‘s good for the long haul. You’ll learn established guidelines for clean coding style and explore techniques to address design considerations like speed, integrity, security, and extensibility.

As you progress, you’ll delve into application design concepts like isolation, encapsulation, and abstract behaviors. You’ll discover techniques for identifying data and behaviors that should be grouped or isolated, separating data and behaviors effectively, understanding the basics of loose coupling, and refactoring code into independent, focused classes. Helpful examples throughout get you coding as you learn, driving your new skills home. By the end of this straightforward, accessible tutorial, you’ll be writing software like a pro!

What's inside

  • Organizing large Python projects
  • Leveraging abstraction for clean code
  • Writing flexible, reusable code
  • Inheritance and composition
  • Considerations for testing and performance

About the reader

Readers should be familiar with the basics of Python or another OO language like Ruby, Java, or C#.

About the author

Dane Hillard has spent the majority of professional software development career building web applications using Python. He’s passionate about introducing professional software development techniques to the many data scientists, business pros, and other self-taught programmers working with Python.

Manning Early Access Program (MEAP) Read chapters as they are written, get the finished eBook as soon as it’s ready, and receive the pBook long before it's in bookstores.
MEAP combo $49.99 pBook + eBook + liveBook
MEAP eBook $39.99 pdf + ePub + kindle + liveBook
Prices displayed in rupees will be charged in USD when you check out.

placing your order...

Don't refresh or navigate away from the page.

FREE domestic shipping on three or more pBooks