Daniel Arbuckle's mastering Python : build powerful Python applications / Daniel Arbuckle.

Format:

Book

Author/Creator:

Arbuckle, Daniel, author.

Language:

English

Subjects (All):

Python (Computer program language).

Physical Description:

1 online resource (1 volume) : illustrations

Edition:

1st edition

Other Title:

Mastering Python

Place of Publication:

Birmingham, [England] ; Mumbai, [India] : Packt, 2017.

System Details:

text file

Biography/History:

Arbuckle Daniel: Daniel Arbuckle gained his PhD in Computer Science from the University of Southern California. He has published numerous papers along with several books and video courses, and he is both a teacher of computer science and a professional programmer.

Summary:

Gain a thorough understanding of operating in a Python development environment, and some of the most important advanced topics with Daniel Arbuckle. This dynamic, concise book is full of real-world solutions for Python 3.6 problems, and advanced-level concepts such as reactive programming, microservices, ctypes and Cython. About This Book Covers the latest and advanced concepts of Python such as parallel processing with Python 3.6 Explore the Python language from its basic installation and setup to concepts such as reactive programming and microservices Get introduced to the mechanism for rewriting code in a compiled language along with ctypes and Cython tools Who This Book Is For If you are a programmer and are familiar with the basics of Python, and you want to broaden your knowledge base to develop projects better and faster, this book is for you. Even if you are not familiar with Python, Daniel Arbuckle's Mastering Python starts with the basics and takes you on a journey to become an expert in the technology. What You Will Learn Get to grips with the basics of operating in a Python development environment Build Python packages to efficiently create reusable code Become proficient at creating tools and utility programs in Python Use the Git version control system to protect your development environment from unwanted changes Harness the power of Python to automate other software Distribute computational tasks across multiple processors Handle high I/O loads with asynchronous I/O to get a smoother performance Take advantage of Python's metaprogramming and programmable syntax features Get acquainted with the concepts behind reactive programming and RxPy In Detail 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. ...

Contents:

Cover

Copyright

Credits

About the Author

www.PacktPub.com

Customer Feedback

Table of Contents

Preface

Chapter 1: 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

Chapter 2: 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

Chapter 3: 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

Chapter 4: 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

Chapter 5: 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

Chapter 6: 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

Chapter 7: 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

Chapter 8: Metaprogramming

Using function decorators

Using the @ syntax in a function decorator

Global decorator - @staticmethod

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

Chapter 9: 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

Chapter 10: 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

Chapter 11: 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

Chapter 12: 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

Index.

Notes:

Includes index.

Description based on online resource; title from PDF title page (ebrary, viewed October 19, 2017).

OCLC:

995052709