- Mastering Python
- Table of Contents
- Mastering Python
- Credits
- About the Author
- About the Reviewers
- www.PacktPub.com
- Preface
- 1. Getting Started – One Environment per Project
- 2. Pythonic Syntax, Common Pitfalls, and Style Guide
- Code style – or what is Pythonic code?
- Formatting strings – printf-style or str.format?
- PEP20, the Zen of Python
- Beautiful is better than ugly
- Explicit is better than implicit
- Simple is better than complex
- Flat is better than nested
- Sparse is better than dense
- Readability counts
- Practicality beats purity
- Errors should never pass silently
- In the face of ambiguity, refuse the temptation to guess
- One obvious way to do it
- Now is better than never
- Hard to explain, easy to explain
- Namespaces are one honking great idea
- Conclusion
- Explaining PEP8
- Verifying code quality, pep8, pyflakes, and more
- Common pitfalls
- Summary
- Code style – or what is Pythonic code?
- 3. Containers and Collections – Storing Data the Right Way
- Time complexity – the big O notation
- Core collections
- Advanced collections
- ChainMap – the list of dictionaries
- counter – keeping track of the most occurring elements
- deque – the double ended queue
- defaultdict – dictionary with a default value
- namedtuple – tuples with field names
- enum – a group of constants
- OrderedDict – a dictionary where the insertion order matters
- heapq – the ordered list
- bisect – the sorted list
- Summary
- 4. Functional Programming – Readability Versus Brevity
- Functional programming
- list comprehensions
- dict comprehensions
- set comprehensions
- lambda functions
- functools
- itertools
- accumulate – reduce with intermediate results
- chain – combining multiple results
- combinations – combinatorics in Python
- permutations – combinations where the order matters
- compress – selecting items using a list of Booleans
- dropwhile/takewhile – selecting items using a function
- count – infinite range with decimal steps
- groupby – grouping your sorted iterable
- islice – slicing any iterable
- Summary
- 5. Decorators – Enabling Code Reuse by Decorating
- 6. Generators and Coroutines – Infinity, One Step at a Time
- 7. Async IO – Multithreading without Threads
- 8. Metaclasses – Making Classes (Not Instances) Smarter
- 9. Documentation – How to Use Sphinx and reStructuredText
- 10. Testing and Logging – Preparing for Bugs
- 11. Debugging – Solving the Bugs
- 12. Performance – Tracking and Reducing Your Memory and CPU Usage
- 13. Multiprocessing – When a Single CPU Core Is Not Enough
- 14. Extensions in C/C++, System Calls, and C/C++ Libraries
- 15. Packaging – Creating Your Own Libraries or Applications
- Index
This chapter explained a few different debugging techniques and gotchas. There is, of course, much more that can be said about debugging, but I hope you have acquired a nice vantage point for debugging your Python code now. Interactive debugging techniques are very useful for single-threaded applications and locations where interactive sessions are available. But since that's not always the case, we also discussed some non-interactive options.
Here's an overview of all the points discussed in this chapter:
- Non-interactive debugging using:
printloggingtracetracebackasynciofaulthandler
- Interactive debugging using both
pdbandipdb
In the next chapter, we will see how to monitor and improve both CPU and memory performance, as well as finding and fixing memory leaks.
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.