Book Image

Daniel Arbuckle's Mastering Python

By : Daniel Arbuckle

Book Image

Daniel Arbuckle's Mastering Python

By: Daniel Arbuckle

Overview of this book

Daniel Arbuckle's Mastering Python covers the basics of operating in a Python development environment, before moving on to more advanced topics. Daniel presents you with real-world solutions to Python 3.6 and advanced-level concepts, such as reactive programming, microservices, ctypes, and Cython tools. You don't need to be familiar with the Python language to use this book, as Daniel starts with a Python primer. Throughout, Daniel highlights the major aspects of managing your Python development environment, shows you how to handle parallel computation, and helps you to master asynchronous I/O with Python 3.6 to improve performance. Finally, Daniel will teach you the secrets of metaprogramming and unit testing in Python, helping you acquire the perfect skillset to be a Python expert. Daniel will get you up to speed on everything from basic programming practices to high-end tools and techniques, things that will help set you apart as a successful Python programmer.

Preface

What this book covers

What you need for this book

Who this book is for

Reader feedback

Customer support

Free Chapter

Python Primer

Python basic syntax and block structure

Python's built-in data structures and comprehensions

First-class functions and classes

The standard library

What's new in modern Python

Setting Up

Downloading and installing Python

Using the command line and the interactive shell

Installing packages with pip

Finding packages in the Python Package Index

Making a Package

Making a Package

Creating an empty package

Adding modules to the package

Accessing code from other modules

Adding static data files to the package

Basic Best Practices

Basic Best Practices

PEP 8 and writing readable code

Using version control

Using venv to create a stable and isolated work area

Getting the most out of docstrings

Making a Command-Line Utility

Making a Command-Line Utility

Making a package executable via Python -m

Handling command-line arguments with argparse

Python tools to interact with the user

Executing other programs with subprocess

Setting up a shell script or batch file to launch the program

Parallel Processing

Parallel Processing

Using the concurrent.futures package

Using the multiprocessing packages

Coroutines and Asynchronous I/O

Coroutines and Asynchronous I/O

The difference between asynchronous processing and parallel processing

Using the asyncio event loop and coroutine scheduler

Awaiting data availability

Synchronizing multiple tasks

Communicating across the network

Metaprogramming

Metaprogramming

Using function decorators

Function annotations

Class decorators

Context managers

Unit Testing

Understanding the principle of unit testing

Using the unittest package

Using unittest.mock

Using unittest's test discovery

Using nose for unified test discovery and reporting

Reactive Programming

Reactive Programming

The concept of reactive programming

Building a simple reactive programming framework

Using the reactive extensions for Python (RxPY)

Microservices

Microservices and the advantages of process isolation

Building high-level microservices with Flask

Building high-level microservices with nameko

Extension Modules and Compiled Code

Extension Modules and Compiled Code

Advantages and disadvantages of compiled code

Accessing a dynamic library using ctypes

Interfacing with C code using Cython

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Summary

At the start of the chapter, we looked at what microservices are philosophically and what their advantages are, and implemented an HTTP-oriented microservice using Flask.

We then looked at some of the advantages of process-based modularity and saw how applying those principles to web applications results in a microservice architecture. We looked at the details needed to use Flask to create a RESTful microservice and put that knowledge to use by building a simple person management microservice.

Next, we looked at using nameko's RPC mechanism to implement a microservice, which simplifies the code significantly, at the cost of requiring that we set up an AMQP infrastructure and a more difficult interface with systems outside the AMQP network.

In the next chapter, we'll look at how to interface between Python and compiled code to optimize performance bottlenecks...