Practices of the Python Pro
FREEYou can see any available part of this book for free.
Click the table of contents to start reading.
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.
Exactly what I'd hoped for in a book with this title.
Table of Contents takes you straight to the bookdetailed 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
Part 2: Foundations of design
2 Separation of concerns
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
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.1 Expectations of privacy in Python
3.2.2 Try it out
3.3 Programming styles are an abstraction, too!
3.3.1 Procedural programming
3.3.2 Functional programming
3.3.3 Declarative programming
3.4 Typing, inheritance, and polymorphism
3.5 Recognizing the wrong abstraction
3.5.1 Square pegs in round holes
3.5.2 Clever gets the cleaver
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.2 CPU profiling
4.5 Try it out
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
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
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
8 The rules (and exceptions) of inheritance
9 Keeping things lightweight
10 Achieving loose coupling
Part 4: What’s Next?
11 Circling back
12 Where to go from here
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.4 Verifying the installation
About the TechnologyNo 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 bookPractices 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!
- Organizing large Python projects
- Leveraging abstraction for clean code
- Writing flexible, reusable code
- Inheritance and composition
- Considerations for testing and performance
About the readerReaders should be familiar with the basics of Python or another OO language like Ruby, Java, or C#.
About the authorDane 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.
placing your order...Don't refresh or navigate away from the page.
customers also bought