Log In
Or create an account -> 
Imperial Library
  • Home
  • About
  • News
  • Upload
  • Forum
  • Help
  • Login/SignUp

Index
Daniel Arbuckle\\\'s Mastering Python Title Page Copyright Daniel Arbuckle's Mastering Python Credits About the Author www.PacktPub.com Why subscribe? Customer Feedback Table of Contents 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
  • ← Prev
  • Back
  • Next →
  • ← Prev
  • Back
  • Next →

Chief Librarian: Las Zenow <zenow@riseup.net>
Fork the source code from gitlab.

This is a mirror of the Tor onion service:
http://kx5thpx2olielkihfyo4jgjqfb7zx7wxr3sd4xzt26ochei4m6f7tayd.onion