Daniel Arbuckle’s Mastering Python电子书

Title Page

Copyright

Daniel Arbuckle's Mastering Python

Credits

About the Author

www.PacktPub.com

Why subscribe?

Customer Feedback

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

Python Primer

Python basic syntax and block structure

Basic building blocks

Functions

Variables

Expressions

Classes

Flow control statements

Indentation

Python's built-in data structures and comprehensions

Dictionaries

List

Tuple

Set

Comprehension

First-class functions and classes

The defaultdict class

Attributes

The standard library

Different types of packages

What's new in modern Python

The changes in the syntactic

Changes in packages

Other changes in Python packages

Summary

Setting Up

Downloading and installing Python

Choosing a suitable version

Installing Python

Using the command line and the interactive shell

Opening a command-line window

Python interactive shell

Installing packages with pip

The pip tool for packages

Managing installed packages

Finding packages in the Python Package Index

Using keywords

Using Package Index

Searching the Package Index with pip

Legalities and licenses of the Python Package Index

Summary

Making a Package

Creating an empty package

Turning a regular folder into a package

Importing all package modules

Adding modules to the package

Module loading with namespace packages

The Package structure and interface

Accessing code from other modules

Importing a cyclic dependency

Resolving attribute errors raised due to cyclic dependencies

Adding static data files to the package

Summary

Basic Best Practices

PEP 8 and writing readable code

PEP 8 — guidelines for Python code

Code indentation

Formatting recommendations

Naming conventions

Using version control

Initializing Git

Committing the changes in Git

Undoing the changes

Branches

Merging codes

The mergetool command

The pull command

Using venv to create a stable and isolated work area

Creating a virtual environment

Activating a virtual environment

pip in virtual environments

Getting the most out of docstrings

PEP 257 and docutils

Sphinx

Turning docstrings into HTML

Using doctest to test documentation examples

Testing examples using doctest

What it means when a code example fails

Summary

Making a Command-Line Utility

Making a package executable via Python -m

Pipeline program

Handling command-line arguments with argparse

Creating an ArgumentParser object

Setting the name of argument

nargs

Python tools to interact with the user

Python's built-in functions - print and input

The getpass package

The pprint package

The cmd class

The Pipeline user interface

Executing other programs with subprocess

Subprocess and its variants

Using the Popen subprocess

The PIPE constant

The wait method

Finishing up our code example

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

Creating launches for our program

Summary

Parallel Processing

Using the concurrent.futures package

The concurrent.futures module

Calling ProcessPoolExecutor

Using the map method

Using the submit method

The done and result methods

The wait and as_completed functions

The add done callback function

The cancel method

Using the multiprocessing packages

Process class in the multiprocessing module

Queues

Pipes

Manager

The lock object

The event object

The condition object

The semaphore object

Summary

Coroutines and Asynchronous I/O

The difference between asynchronous processing and parallel processing

Multithreading is not good for servers

Cooperative coroutine scheduler versus coroutine

Python coroutines

The coroutine scheduler

Using the asyncio event loop and coroutine scheduler

Creating a coroutine

The asyncio scheduler - event_loop

ensure_future

The run_forever/run_until_complete methods

Closing event_loop

Awaiting data availability

asyncio's future objects

Asynchronous iterations

Synchronizing multiple tasks

Synchronization primitives

The wait coroutine

The wait_for coroutine

The gather coroutine

The asyncio Queue class

Queue types

Communicating across the network

Creating a simple client in asyncio

Creating a simple server in asyncio

Handling client disconnections

Summary

Metaprogramming

Using function decorators

Using the @ syntax in a function decorator

Global decorator - @staticmethod

Attributes

Enclosing the function in a wrapper

The @wraps decorator

The only function

Function annotations

Function annotation syntax

Accessing annotation data

The @no_type_check decorator

Annotations as input to function decorators

Keyword arguments

Inspecting the package signature function

Class decorators

Modifying class attributes

The factory function

The factory_constructed function

Class definitions

Metaclasses

What can we do with a metaclass?

The __prepare__method

The __new__ method

Context managers

Defining a context manager as a generator

Adding context manager behavior to a class

Synchronous-coroutine-based context managers

Creating an asynchronous-coroutine-based context manager

Descriptors

Using @property to create a descriptor

Writing descriptors as classes

Summary

Unit Testing

Understanding the principle of unit testing

What is a unit test?

Using the unittest package

Structuring a test file

assert methods

Comparing what happens to what should happen in unit tests

Using unittest.mock

What is a mock object?

Preconfiguring mock objects

assert methods of mock objects

The unittest.mock patch function

Using unittest's test discovery

Unittest's discovery tool

Command-line options in unit test discovery

Using nose for unified test discovery and reporting

Running our tests with nose

The cover-package option

Testing multiple worker processes

Summary

Reactive Programming

The concept of reactive programming

Building a simple reactive programming framework

Observers

Observables

Emitting events

Building the observable sequence

Illustrating a stream of animal events

Composing an observable sequence

Using the reactive extensions for Python (RxPY)

Translating our zoo demo into Rx

Observable factory methods

Explaining the observable sequence of events

Creating an asyncio scheduler

Combining and processing observable sequences

Miscellaneous observable factory methods

The Observable.create method

The Observable.select_many method

Empty, return_value, and from_iterable factory methods

The where factory method

Summary

Microservices

Microservices and the advantages of process isolation

Advantages of the microservice architecture

Applying the microservice architecture to web servers

Building high-level microservices with Flask

Installing Flask

Creating endpoints for a RESTful API in Flask

Building a microservice to maintain a database

Making Flask handle a request

Running and connecting to our microservice using Flask

Test running the microservice

Building high-level microservices with nameko

Installing nameko

Running and connecting a microservice using nameko

Things to know before using nameko

Interacting with our microservice

Interacting with a microservice manually using the nameko shell

Interacting with a microservice by creating another microservice

Summary

Extension Modules and Compiled Code

Advantages and disadvantages of compiled code

The downsides of compiled code

Accessing a dynamic library using ctypes

Locating and linking a dynamic library

Accessing functions defined in the library

Assigning attributes to a function

Using a pointer as a parameter of a function

Providing a function signature

Providing data structure layouts

Interfacing with C code using Cython

Working with Cython

Additional import methods in Cython

Writing extension modules in Cython

Methods to increase the execution speed of Python code

Using cpdef in a Cython class

Compiling an extension module in Python

Summary