Daniel Arbuckle's Mastering Python : building powerful Python applications /

Mostrar otras versiones (1)

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, microserv...

Descripción completa

Detalles Bibliográficos
Clasificación:Libro Electrónico
Autor principal: Arbuckle, Daniel (Autor)
Formato: Electrónico eBook
Idioma:Inglés
Publicado: Birmingham, UK : Packt Publishing, 2017.
Temas:
Python (Computer program language)
Application software > Development.
Python (Langage de programmation)
Logiciels d'application > Développement.
COMPUTERS > Software Development & Engineering > General.
COMPUTERS > Programming Languages > Python.
Acceso en línea:Texto completo
Texto completo
Tabla de Contenidos:
  • 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
  • Summary
  • 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
  • Summary
  • 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
  • Summary
  • 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
  • Summary
  • 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
  • Summary
  • 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
  • Summary
  • Chapter 8: 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
  • 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
  • Summary
  • 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
  • Summary
  • 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
  • Summary
  • 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
  • Summary
  • Index.

Ejemplares similares