Book Image

Mastering Python 2E - Second Edition

By : Rick van Hattem

5 (1)

Book Image

Mastering Python 2E - Second Edition

5 (1)

By: Rick van Hattem

Overview of this book

Even if you find writing Python code easy, writing code that is efficient, maintainable, and reusable is not so straightforward. Many of Python’s capabilities are underutilized even by more experienced programmers. Mastering Python, Second Edition, is an authoritative guide to understanding advanced Python programming so you can write the highest quality code. This new edition has been extensively revised and updated with exercises, four new chapters and updates up to Python 3.10. Revisit important basics, including Pythonic style and syntax and functional programming. Avoid common mistakes made by programmers of all experience levels. Make smart decisions about the best testing and debugging tools to use, optimize your code’s performance across multiple machines and Python versions, and deploy often-forgotten Python features to your advantage. Get fully up to speed with asyncio and stretch the language even further by accessing C functions with simple Python calls. Finally, turn your new-and-improved code into packages and share them with the wider Python community. If you are a Python programmer wanting to improve your code quality and readability, this Python book will make you confident in writing high-quality scripts and taking on bigger challenges

Preface

Who this book is for

What this book covers

To get the most out of this book

Free Chapter

Getting Started – One Environment per Project

Getting Started – One Environment per Project

Virtual environments

Managing dependencies

Interactive Python Interpreters

Interactive Python Interpreters

The Python interpreter

Alternative interpreters

Pythonic Syntax and Common Pitfalls

Pythonic Syntax and Common Pitfalls

A brief history of Python

Code style – What is Pythonic code?

Common pitfalls

Pythonic Design Patterns

Pythonic Design Patterns

Time complexity – The big O notation

Core collections

Pythonic patterns using advanced collections

Functional Programming – Readability Versus Brevity

Functional Programming – Readability Versus Brevity

Functional programming

list, set, and dict comprehensions

lambda functions

Decorators – Enabling Code Reuse by Decorating

Decorators – Enabling Code Reuse by Decorating

Decorating functions

Decorating class functions

Decorating classes

Useful decorators

Generators and Coroutines – Infinity, One Step at a Time

Generators and Coroutines – Infinity, One Step at a Time

Generator examples

Metaclasses – Making Classes (Not Instances) Smarter

Metaclasses – Making Classes (Not Instances) Smarter

Dynamically creating classes

A basic metaclass

Abstract classes using collections.abc

Automatically registering plugin systems

Order of operations when instantiating classes

Storing class attributes in definition order

Documentation – How to Use Sphinx and reStructuredText

Documentation – How to Use Sphinx and reStructuredText

reStructuredText and Markdown

The Sphinx documentation generator

Documenting code

Testing and Logging – Preparing for Bugs

Testing and Logging – Preparing for Bugs

Using documentation as tests with doctest

Testing with py.test

Testing multiple environments with tox

Debugging – Solving the Bugs

Debugging – Solving the Bugs

Non-interactive debugging

Interactive debugging

Performance – Tracking and Reducing Your Memory and CPU Usage

Performance – Tracking and Reducing Your Memory and CPU Usage

What is performance?

Measuring CPU performance and execution time

Improving execution time

Performance monitoring

asyncio – Multithreading without Threads

asyncio – Multithreading without Threads

Introduction to asyncio

Asynchronous examples

Debugging asyncio

Multiprocessing – When a Single CPU Core Is Not Enough

Multiprocessing – When a Single CPU Core Is Not Enough

The Global Interpreter Lock (GIL)

Multiple threads and processes

Sharing data between threads and processes

Processes, threads, or a single thread?

Hyper-threading versus physical CPU cores

Remote processes

Scientific Python and Plotting

Scientific Python and Plotting

Installing the packages

Arrays and matrices

Mathematics and precise calculations

Plotting, graphing, and charting

Artificial Intelligence

Artificial Intelligence

Introduction to artificial intelligence

Installing the packages

Image processing

Natural language processing

Machine learning

Versatile AI libraries and utilities

Extensions in C/C++, System Calls, and C/C++ Libraries

Extensions in C/C++, System Calls, and C/C++ Libraries

Setting up tooling

Calling C/C++ with ctypes

Native C/C++ extensions

Packaging – Creating Your Own Libraries or Applications

Packaging – Creating Your Own Libraries or Applications

Introduction to packages

Package versioning

Building packages

Publishing packages

C/C++ extensions

Other Books You May Enjoy

Other Books You May Enjoy

Index

Customer Reviews

5 (1)

5 star

100%

4 star

0

3 star

0

2 star

0

1 star

0

Exercises

The possibilities with external libraries are endless, so perhaps you already have some ideas about what to implement. If not, here’s some inspiration:

Try to sort a list of numbers using ctypes, CFFI, and with a native extension. You can use the qsort function in stdlib.
Try to make the custom_sum function we created safer by adding proper errors for overflow/underflow issues. Additionally, catch the errors when summing multiple numbers that only overflow or underflow in summation.

These exercises should be a nice starting point for doing something useful with your newly acquired knowledge. If you are looking for more of the native C/C++ examples, I would recommend looking through the CPython source. There are many examples available: https://github.com/python/cpython/tree/main/Modules. I would suggest starting with a relatively simple one such as the bisect module.

Example answers for these exercises can be found on GitHub: https...