會員

Daniel Arbuckle's Mastering Python

更新時間：2021-07-02 21:10:27

開會員，本書免費讀 >

IfyouareaprogrammerandarefamiliarwiththebasicsofPython,andyouwanttobroadenyourknowledgebasetodevelopprojectsbetterandfaster,thisbookisforyou.EvenifyouarenotfamiliarwithPython,DanielArbuckle'sMasteringPythonstartswiththebasicsandtakesyouonajourneytobecomeanexpertinthetechnology.

目錄(277章)

倒序

coverpage
Title Page
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 更新時間：2021-07-02 21:10:27

官术网_书友最值得收藏!

Daniel Arbuckle's Mastering Python