Python is simple to learn. In fact, it is one of the easiest programming languages to learn - so much so that schools are using it. However, many of us reach a level of python usage and stop there. Yes, I’m looking at you: thrilled at using a list comprehension, map and zip together and thought yourself a Pythonista? Yet, we know that we haven’t written a lot of production code that is used by many users. How to bridge said gap? How do the experts do it? This book claims to shows how.

So, if you know your basics, use the libraries quite well but you want to write modules that others use or some cool multi-threaded cluster in the cloud stuff, you are the right audience for this book.

In Brief

The book has 14 chapters. Chapters 1-3 are Python, beyond basics. Chapters 4-7 cover advanced Python. Chapters 8-14 are domain specific uses. Let's see what each section holds for us.

Beyond the Basics

This section is quite underwhelming in that it doesn’t really bring much new information to an intermediate developer. Chapter 2 is packaged (pardon the pun) with useful information on modules and packages: how to write a well-designed module and package it. Chapter 3 purports to be ‘advanced’ object oriented programming, but really gives toy examples of OOP concepts in Python.

Advanced Python

Chapter 4 introduces the intermediate programmer to quite a few new concepts:

  1. __iter__(self) and __next__(self) methods to make your own iterables.
  2. Generator Expressions and pipelining generators
  3. How the with keyword works internally

The chapter has sections on file handling and exceptions that are not very advanced. The section on logging, however, is quite detailed.

Chapter 5 is about testing - the author goes deep into unit testing while also briefly touching upon other tests, TDD and CI/CD

Chapter 6 covers itertools, zip, map and filter before going deep into nested functions and decorators. An overview of different comprehensions is followed by a detailed section on pandas, showing tricks and tips for better data analysis.

Chapter 7 is a deep dive into concurrent programming in Python. Threads, queues, pipes and async / await are discussed. Most Python programmers are not used to working on such problems and the case study with GCP is appreciable.

Domain Specific

These are introductions to the use of Python in different domains.

Chapters 8 and 9 cover clusters and cloud. Apache Spark and PySpark are the main items of discussions. For those new to the field, the author gives quite a good overview. The chapter covers GCP in more detail and Apache Beam for pipelines in particular.

Chapters 10 to 12 could be said to be about the web domain. We see the use of Flask to build a web application. This is quite comprehensive, including routes, Jinja2 and SQLAlchemy. Code and diagrams give visual clarity.

Chapter 11 discusses microservices and how to use Django Rest Framework and Docker to deploy a microservice.

Chapter 12 looks at the landscape of serverless functions in the Google Cloud environment. Examples and visuals make the topic clear.

Chapter 13 is about Machine Learning. One chapter is not sufficient for ML and it ends up being a superficial overview of the topic. The saving grace is a brief tutorial on how to use GCP for ML tasks.

Chapter 14 covers network automation, a niche topic. Digital transformation is a buzzword and network automation is vital to it. The chapter explores libraries such as NAPALM, Paramiko for device config and how to use NETCONF with Python. Network Mgmt Systems are also discussed.


While having a decent spread of topics, the book feels superficial in some parts. If the reader is familiar with software engineering concepts, this book doesn’t add much value. Developers who have just learnt Python, on the other hand, could find that this book makes them well-rounded and ready to take on real engineering roles.


  • It is a long book: multiple topics are covered
  • Some chapters in the advanced Python section are useful
  • Good for coders who haven’t done much in Software Engineering: perhaps have taken a Python course online but need more grounding in other aspects of development


  • Many chapters have toy examples
  • Most domain specific chapters are very cursory and won’t help readers to get proficient in those domains.
  • Readers will most likely need to get books mentioned at the end of the chapter in this book. So, the raison d’etre of this book is questionable.

Did you like this article?

If you liked this article, consider subscribing to this site. Subscribing is free.

Why subscribe? Here are three reasons:

  1. You will get every new article as an email in your inbox, so you never miss an article
  2. You will be able to comment on all the posts, ask questions, etc
  3. Once in a while, I will be posting conference talk slides, longer form articles (such as this one), and other content as subscriber-only

Tagged in: