Python in a Nutshell. A Desktop Quick Reference. 3rd Edition (ebook)(audiobook)(audiobook)

Spis treści

• Preface
  • How This Book Is Organized
    • Part I, Getting Started with Python
    • Part II, Core Python Language and Built-ins
    • Part III, Python Library and Extension Modules
    • Part IV, Network and Web Programming
    • Part V, Extending, Distributing, v2/v3 Migration
  • Conventions Used in This Book
    • Reference Conventions
    • Version Conventions
    • Typographic Conventions
  • How to Contact Us
  • OReilly Safari
  • Acknowledgments
• I. Getting Started with Python
• 1. Introduction to Python
  • The Python Language
  • The Python Standard Library and Extension Modules
  • Python Implementations
    • CPython
    • Jython
    • IronPython
    • PyPy
    • Choosing Between CPython, Jython, IronPython, and PyPy
    • Other Developments, Implementations, and Distributions
      • Pyjion
      • IPython
      • MicroPython: Is your child already a programmer?
      • Anaconda and Miniconda
      • Nuitka: Convert your Python to C++
      • Grumpy: A Python-to-Go transpiler
      • Transcrypt: Convert your Python to JavaScript
    • Licensing and Price Issues
  • Python Development and Versions
  • Python Resources
    • Documentation
      • Python documentation for nonprogrammers
      • Extension modules and Python sources
      • Books
    • Community
      • Python Software Foundation
      • Python conferences
      • User groups and Meetups
      • Special Interest Groups
      • Social media
      • Mailing lists and newsgroups
  • Installation
  • Installing Python from Binaries
    • macOS
  • Installing Python from Source Code
    • Microsoft Windows
      • Uncompressing and unpacking the Python source code
      • Building the Python source code
    • Unix-Like Platforms
      • Uncompressing and unpacking the Python source code
      • Configuring, building, and testing
      • Installing after the build
  • Installing Jython
  • Installing IronPython
  • Installing PyPy
• 2. The Python Interpreter
  • The python Program
    • Environment Variables
    • Command-Line Syntax and Options
    • Interactive Sessions
  • Python Development Environments
    • IDLE
    • Other Python IDEs
    • Free Text Editors with Python Support
    • Tools for Checking Python Programs
  • Running Python Programs
  • The jython Interpreter
  • The IronPython Interpreter
  • The PyPy Interpreter
• II. Core Python Language and Built-ins
• 3. The Python Language
  • Lexical Structure
    • Lines and Indentation
    • Character Sets
    • Tokens
      • Identifiers
      • Keywords
      • Operators
      • Delimiters
      • Literals
    • Statements
      • Simple statements
      • Compound statements
  • Data Types
    • Numbers
      • Integer numbers
      • Floating-point numbers
      • Complex numbers
      • New in 3.6: Underscores in numeric literals
    • Sequences
      • Iterables
      • Strings
      • Tuples
      • Lists
    • Sets
    • Dictionaries
    • None
    • Callables
    • Boolean Values
  • Variables and Other References
    • Variables
      • Object attributes and items
      • Accessing nonexistent references
    • Assignment Statements
      • Plain assignment
      • Augmented assignment
    • del Statements
  • Expressions and Operators
    • Comparison Chaining
    • Short-Circuiting Operators
      • The ternary operator
  • Numeric Operations
    • Numeric Conversions
    • Arithmetic Operations
      • Division
      • Exponentiation
    • Comparisons
    • Bitwise Operations on Integers
  • Sequence Operations
    • Sequences in General
      • Sequence conversions
      • Concatenation and repetition
      • Membership testing
      • Indexing a sequence
      • Slicing a sequence
    • Strings
    • Tuples
    • Lists
      • Modifying a list
      • In-place operations on a list
      • List methods
      • Sorting a list
  • Set Operations
    • Set Membership
    • Set Methods
  • Dictionary Operations
    • Dictionary Membership
    • Indexing a Dictionary
    • Dictionary Methods
  • Control Flow Statements
    • The if Statement
    • The while Statement
    • The for Statement
      • Iterators
      • range and xrange
      • List comprehensions
      • Set comprehensions
      • Dict comprehensions
    • The break Statement
    • The continue Statement
    • The else Clause on Loop Statements
    • The pass Statement
    • The try and raise Statements
    • The with Statement
  • Functions
    • The def Statement
    • Parameters
      • Function signatures
    • Keyword-only Parameters (v3 Only)
    • Attributes of Function Objects
      • Docstrings
      • Other attributes of function objects
    • Function Annotations and Type Hints (v3 Only)
      • Type hints (Python 3.5 only)
      • New in 3.6: Type annotations
    • The return Statement
    • Calling Functions
      • The semantics of argument passing
      • Kinds of arguments
    • Namespaces
      • The global statement
      • Nested functions and nested scopes
    • lambda Expressions
    • Generators
      • yield from (v3-only)
      • Generator expressions
      • Generators as near-coroutines
    • Recursion
• 4. Object-Oriented Python
  • Classes and Instances
    • Python Classes
    • The class Statement
    • The Class Body
      • Attributes of class objects
      • Function definitions in a class body
      • Class-private variables
      • Class documentation strings
    • Descriptors
      • Overriding and nonoverriding descriptors
    • Instances
      • __init__
      • Attributes of instance objects
      • The factory-function idiom
      • __new__
    • Attribute Reference Basics
      • Getting an attribute from a class
      • Getting an attribute from an instance
      • Setting an attribute
    • Bound and Unbound Methods
      • Unbound method details (v2 only)
      • Bound method details
    • Inheritance
      • Method resolution order
      • Overriding attributes
      • Delegating to superclass methods
      • Cooperative superclass method calling
      • Deleting class attributes
    • The Built-in object Type
    • Class-Level Methods
      • Static methods
      • Class methods
    • Properties
      • Why properties are important
      • Properties and inheritance
    • __slots__
    • __getattribute__
    • Per-Instance Methods
    • Inheritance from Built-in Types
  • Special Methods
    • General-Purpose Special Methods
    • Special Methods for Containers
      • Sequences
      • Mappings
      • Sets
      • Container slicing
      • Container methods
    • Abstract Base Classes
      • abc
      • ABCs in the collections module
      • The numbers module
    • Special Methods for Numeric Objects
  • Decorators
  • Metaclasses
    • How Python v2 Determines a Classs Metaclass
    • How Python v3 Determines a Classs Metaclass
    • How a Metaclass Creates a Class
      • Defining and using your own metaclasses
      • A substantial custom metaclass example
• 5. Exceptions
  • The try Statement
    • try/except
    • try/finally
    • The try/except/finally Statement
  • The with Statement and Context Managers
    • Generators and Exceptions
  • Exception Propagation
  • The raise Statement
  • Exception Objects
    • The Hierarchy of Standard Exceptions
    • Standard Exception Classes
      • OSError and subclasses (v3 only)
      • Exceptions wrapping other exceptions or tracebacks
  • Custom Exception Classes
    • Custom Exceptions and Multiple Inheritance
    • Other Exceptions Used in the Standard Library
  • Error-Checking Strategies
    • LBYL Versus EAFP
      • Proper usage of EAFP
    • Handling Errors in Large Programs
    • Logging Errors
      • The logging package
  • The assert Statement
    • The __debug__ Built-in Variable
• 6. Modules
  • Module Objects
    • The import Statement
      • Module body
      • Attributes of module objects
      • Python built-ins
      • Module documentation strings
      • Module-private variables
    • The from Statement
      • from ... import *
      • from versus import
  • Module Loading
    • Built-in Modules
    • Searching the Filesystem for a Module
    • The Main Program
    • Reloading Modules
    • Circular Imports
    • sys.modules Entries
    • Custom Importers
      • Rebinding __import__
      • Import hooks
  • Packages
    • Special Attributes of Package Objects
    • Namespace Packages (v3 Only)
    • Absolute Versus Relative Imports
  • Distribution Utilities (distutils) and setuptools
    • Python Wheels (and Eggs)
  • Python Environments
    • Enter the Virtual Environment
    • What Is a Virtual Environment?
    • Creating and Deleting Virtual Environments
    • Working with Virtual Environments
    • Managing Dependency Requirements
    • Best Practices with virtualenvs
• 7. Core Built-ins and Standard Library Modules
  • Built-in Types
  • Built-in Functions
  • The sys Module
  • The copy Module
  • The collections Module
    • ChainMap (v3 Only)
    • Counter
    • OrderedDict
    • defaultdict
    • deque
    • namedtuple
  • The functools Module
  • The heapq Module
    • The Decorate-Sort-Undecorate Idiom
  • The argparse Module
  • The itertools Module
• 8. Strings and Things
  • Methods of String and Bytes Objects
  • The string Module
  • String Formatting
    • Value Selection
    • Value Conversion
    • Value Formatting
      • Alignment, with optional (preceding) fill
      • Optional sign indication
      • Radix indicator
      • Field width
      • Comma separation
      • Precision specification
      • Format type
      • Nested format specifications
      • Formatting of user-coded classes
    • New in 3.6: Formatted String Literals
    • Legacy String Formatting with %
    • Format Specifier Syntax
      • When to use %r
  • Text Wrapping and Filling
  • The pprint Module
  • The reprlib Module
  • Unicode
    • The codecs Module
    • The unicodedata Module
• 9. Regular Expressions
  • Regular Expressions and the re Module
    • re and bytes Versus Unicode Strings
    • Pattern-String Syntax
    • Common Regular Expression Idioms
    • Sets of Characters
    • Alternatives
    • Groups
    • Optional Flags
    • Match Versus Search
    • Anchoring at String Start and End
    • Regular Expression Objects
    • Match Objects
    • Functions of the re Module
• III. Python Library and Extension Modules
• 10. File and Text Operations
  • Other Chapters That Also Deal with Files
  • Organization of This Chapter
  • The io Module
    • Creating a file Object with io.open
      • mode
      • Binary and text modes
      • Buffering
      • Sequential and nonsequential (random) access
    • Attributes and Methods of file Objects
    • Iteration on File Objects
    • File-Like Objects and Polymorphism
    • The tempfile Module
  • Auxiliary Modules for File I/O
    • The fileinput Module
    • The linecache Module
    • The struct Module
  • In-Memory Files: io.StringIO and io.BytesIO
  • Compressed Files
    • The gzip Module
      • A gzip example
    • The bz2 Module
    • The tarfile Module
    • The zipfile Module
    • The zlib Module
  • The os Module
    • OSError Exceptions
    • The errno Module
  • Filesystem Operations
    • Path-String Attributes of the os Module
    • Permissions
    • File and Directory Functions of the os Module
    • The os.path Module
    • The stat Module
    • The filecmp Module
      • dircmp instance attributes
    • The fnmatch Module
    • The glob Module
    • The shutil Module
    • File Descriptor Operations
  • Text Input and Output
    • Standard Output and Standard Error
    • The print Function
    • Standard Input
    • The getpass Module
  • Richer-Text I/O
    • The readline Module
    • Console I/O
      • The curses package
      • The msvcrt Module
  • Interactive Command Sessions
    • Initializing a Cmd Instance
    • Methods of Cmd Instances
    • Attributes of Cmd Instances
    • A Cmd Example
  • Internationalization
    • The locale Module
    • The gettext Module
      • Using gettext for localization
      • Essential gettext functions
    • More Internationalization Resources
• 11. Persistence and Databases
  • Serialization
    • The json Module
      • A JSON example
    • The pickle and cPickle Modules
      • Functions and classes of pickle and cPickle
      • A pickling example
      • Pickling instances
      • Pickling customization with the copy_reg module
    • The shelve Module
      • A shelving example
  • DBM Modules
    • The v3 dbm Package
    • v2s dbm modules
    • Examples of DBM-Like File Use
  • Berkeley DB Interfacing
  • The Python Database API (DBAPI) 2.0
    • Exception Classes
    • Thread Safety
    • Parameter Style
    • Factory Functions
    • Type Description Attributes
    • The connect Function
    • Connection Objects
    • Cursor Objects
    • DBAPI-Compliant Modules
    • SQLite
    • class sqlite3.Connection
    • class sqlite3.Row
      • A sqlite3 example
• 12. Time Operations
  • The time Module
  • The datetime Module
    • The date Class
    • The time Class
    • The datetime Class
    • The timedelta Class
  • The pytz Module
  • The dateutil Module
  • The sched Module
  • The calendar Module
• 13. Controlling Execution
  • Site and User Customization
    • The site and sitecustomize Modules
    • User Customization
  • Termination Functions
  • Dynamic Execution and exec
    • Avoiding exec
    • Expressions
    • Compile and Code Objects
    • Never exec or eval Untrusted Code
  • Internal Types
    • Type Objects
    • The Code Object Type
    • The frame Type
  • Garbage Collection
    • The gc Module
    • The weakref Module
• 14. Threads and Processes
  • Threads in Python
  • The threading Module
    • Thread Objects
    • Thread Synchronization Objects
      • Timeout parameters
      • Lock and RLock objects
      • Condition objects
      • Event objects
      • Semaphore objects
      • Timer objects
      • Barrier objects (v3 only)
    • Thread Local Storage
  • The queue Module
    • Methods of Queue Instances
  • The multiprocessing Module
    • Differences Between Multiprocessing and Threading
      • Structural differences
        • The Process class
      • Differences in queues
      • Differences in synchronization primitives
    • Sharing State: Classes Value, Array, and Manager
      • The Value class
      • The Array class
      • The Manager class
    • Multiprocessing Pool
      • The Pool class
      • The AsyncResult class
  • The concurrent.futures Module
  • Threaded Program Architecture
  • Process Environment
  • Running Other Programs
    • Running Other Programs with the os Module
    • The Subprocess Module
      • What to run, and how: args, executable, shell
      • Subprocess files: stdin, stdout, stderr, bufsize, universal_newlines, close_fds
      • Other arguments: preexec_fn, cwd, env, startupinfo, creationflags
      • Attributes of subprocess.Popen instances
      • Methods of subprocess.Popen instances
  • The mmap Module
    • Methods of mmap Objects
    • Using mmap Objects for IPC
• 15. Numeric Processing
  • The math and cmath Modules
  • The operator Module
  • Random and Pseudorandom Numbers
    • Physically Random and Cryptographically Strong Random Numbers
    • The random Module
  • The fractions Module
  • The decimal Module
  • The gmpy2 Module
  • Array Processing
  • The array Module
  • Extensions for Numeric Array Computation
    • NumPy
    • Creating a NumPy Array
    • Shape, Indexing, and Slicing
    • Matrix Operations in NumPy
    • SciPy
• 16. Testing, Debugging, and Optimizing
  • Testing
    • Unit Testing and System Testing
    • The doctest Module
    • The unittest Module
      • The TestCase class
      • Unit tests dealing with large amounts of data
  • Debugging
    • Before You Debug
    • The inspect Module
      • Introspecting callables in v3
      • An example of using inspect
    • The traceback Module
    • The pdb Module
  • The warnings Module
    • Classes
    • Objects
    • Filters
      • __warningsgregistry__
    • Functions
  • Optimization
    • Developing a Fast-Enough Python Application
    • Benchmarking
    • Large-Scale Optimization
      • List operations
      • String operations
      • Dictionary operations
      • Set operations
      • Summary of big-O times for operations on Python built-in types
    • Profiling
      • The profile module
      • Calibration
      • The pstats module
    • Small-Scale Optimization
      • The timeit module
      • Building up a string from pieces
      • Searching and sorting
      • Avoid exec and from import *
      • Optimizing loops
      • Optimizing I/O
• IV. Network and Web Programming
• 17. Networking Basics
  • Networking Principles
  • The Berkeley Socket Interface
    • Socket Addresses
    • Client-Server Computing
      • Connectionless client and server structures
      • Connection-oriented client and server structures
    • The socket Module
      • Miscellaneous socket module functions
    • Socket Objects
      • Socket creation functions
    • A Connectionless Socket Client
    • A Connectionless Socket Server
    • A Connection-Oriented Socket Client
    • A Connection-Oriented Socket Server
  • Transport Layer Security (TLS, AKA SSL)
    • SSLContext
• 18. Asynchronous Alternatives
  • Coroutine-Based Async Architectures
  • The asyncio Module (v3 Only)
    • Coroutines in asyncio
      • asyncio coroutines
      • async and await
        • async with
        • async for
    • asyncios Event Loop
      • Loop state and debugging mode
        • asyncio developing and debugging
      • Calls, time, and sleep
      • Connections and server
      • Tasks
      • Watching file descriptors
      • socket operations; hostnames
      • Unix signals
      • Executor
      • Error handling
      • Futures
      • Tasks
      • Transports and protocols
        • Protocol-based examples: echo client and server
        • asyncio streams
    • Synchronization and Queues
      • Asyncio synchronization primitives
      • Asyncio queues
  • The selectors Module
    • selectors Events
    • The SelectorKey Class
    • The BaseSelector Class
    • When to Use selectors
      • selectors echo server example
• 19. Client-Side Network Protocol Modules
  • Email Protocols
    • The poplib Module
    • The smtplib Module
  • HTTP and URL Clients
    • URL Access
      • The urllib.parse (v3) / urlparse (v2) modules
    • The Third-Party requests Package
      • Sending requests
      • requests optional named parameters
        • The files argument (and other ways to specify the requests body)
        • How to study examples of requests
      • The Response class
    • The urllib Package (v3)
    • The urllib Module (v2)
      • Functions
      • The FancyURLopener class
    • The urllib2 Module (v2)
      • Functions
      • The Request class
      • The OpenerDirector class
      • Handler classes
      • Handling authentication
  • Other Network Protocols
• 20. Serving HTTP
  • WSGI
    • WSGI Servers
  • Python Web Frameworks
    • Full-Stack Versus Lightweight Frameworks
      • When you use lightweight frameworks
    • A Few Popular Full-Stack Frameworks
    • Some Popular Lightweight Frameworks
      • Falcon
        • Falcon resources
        • Falcon request objects
        • Falcon response objects
        • Falcon middleware
      • Flask
        • Flask request objects
        • Flask response objects
        • Bottle
        • Bottle routing
        • Bottle request objects
        • Bottle response objects
        • Bottle templating
      • webapp2
        • webapp2 request objects
        • webapp2 response objects
        • webapp2 handlers
        • webapp2 routes
        • webapp2 extras
• 21. Email, MIME, and Other Network Encodings
  • MIME and Email Format Handling
    • Functions in the email Package
    • The email.message Module
    • The email.Generator Module
    • Creating Messages
    • The email.encoders Module
    • The email.utils Module
    • Example Uses of the email Package
    • rfc822 and mimetools Modules (v2)
  • Encoding Binary Data as ASCII Text
    • The base64 Module
    • The quopri Module
    • The uu Module
• 22. Structured Text: HTML
  • The html.entities (v2: htmlentitydefs) Module
    • The BeautifulSoup Third-Party Package
    • The BeautifulSoup Class
      • Which parser BeautifulSoup uses
      • BeautifulSoup, Unicode, and encoding
    • The Navigable Classes of bs4
      • Indexing instances of Tag
      • Getting an actual string
      • Attribute references on instances of BeautifulSoup and Tag
      • contents, children, descendants
      • parent, parents
      • next_sibling, previous_sibling, next_siblings, previous_siblings
      • next_element, previous_element, next_elements, previous_elements
    • bs4 find... Methods (Search Methods)
      • Arguments of search methods
        • Search method arguments: filters
        • Search method arguments: name
        • Search method arguments: string
        • Search method arguments: attrs
        • Search method arguments: other named arguments
    • bs4 CSS Selectors
    • An HTML Parsing Example with BeautifulSoup
  • Generating HTML
    • Editing and Creating HTML with bs4
      • Building and adding new nodes
      • Replacing and removing nodes
    • Building HTML with bs4
    • Templating
    • The jinja2 Package
    • The jinja2.Environment Class
    • The jinja2.Template Class
      • Building HTML with jinja2
• 23. Structured Text: XML
  • ElementTree
    • The Element Class
    • The ElementTree Class
    • Functions in the ElementTree Module
    • Parsing XML with ElementTree.parse
      • Selecting Elements from an ElementTree
      • Editing an ElementTree
    • Building an ElementTree from Scratch
    • Parsing XML Iteratively
      • Parsing XML within an asynchronous loop
• V. Extending, Distributing, v2/v3 Migration
• 24. Extending and Embedding Classic Python
  • Extending Python with Pythons C API
    • Building and Installing C-Coded Python Extensions
      • What C compiler do you need?
      • Compatibility of C-coded extensions among Python versions
    • Overview of C-Coded Python Extension Modules
    • Return Values of Pythons C API Functions
    • The Initialization Module
      • The PyMethodDef struct
    • Reference Counting
    • Accessing Arguments
    • Creating Python Values
    • Exceptions
    • Abstract Layer Functions
    • Concrete Layer Functions
    • A Simple Extension Example
    • Defining New Types
      • Per-instance data
      • The PyTypeObject definition
      • Instance initialization and finalization
      • Attribute access
      • Type definition example
  • Extending Python Without Pythons C API
    • ctypes
  • Cython
    • The cdef and cpdef Statements and Function Parameters
      • External declarations
      • cdef classes
    • The ctypedef Statement
    • The forfrom Statement
    • Cython Expressions
    • A Cython Example: Greatest Common Divisor
  • Embedding Python
    • Installing Resident Extension Modules
    • Setting Arguments
    • Python Initialization and Finalization
    • Running Python Code
• 25. Distributing Extensions and Programs
  • setuptools
    • The Distribution and Its Root
      • Testing your package during development
    • The setup.py Script
      • Metadata about the distribution
      • Distribution contents
        • Python source files
        • What are entry_points?
        • Data and other files
        • C-coded extensions
      • Dependencies and requirements
    • The requirements.txt File
    • The MANIFEST.in File
    • The setup.cfg File
  • Distributing Your Package
    • Create the Distribution
      • Wheels make the Python world go round
        • Pure wheels
        • Nonpure wheels
        • Creating wheels
      • Creating an sdist
    • Registering and Uploading to a Repository
      • Your ~/.pypirc file
      • Register and upload to PyPI
• 26. v2/v3 Migration and Coexistence
  • Preparing for Python 3
  • Minimizing Syntax Differences
    • Avoid Old-Style Classes
    • print as a Function
    • String Literals
    • Numeric Constants
    • Text and Binary Data
    • Never Sort Using cmp
    • except Clauses
    • Division
    • Incompatible Syntax to Avoid for Compatibility
  • Choosing Your Support Strategy
    • Steady As She Goesv2-only Support
    • v2/v3 Support with Conversion
      • v2 source with conversion to v3
      • v3 source with conversion to v2
    • 2to3 Conversion: A Case Study
      • Initial run of 2to3
      • Retaining v2 compatibility
    • v2/v3 Support with a Single Source Tree
      • six
      • python-modernize
      • python-future
    • v3-only Support
• Index

pokaż cały spis treści

ukryj recenzje