0%

Expert Insight for Modern Python (3.6+) Development from the Author of Python Essential Reference

The richness of modern Python challenges developers at all levels. How can programmers who are new to Python know where to begin without being overwhelmed? How can experienced Python developers know they're coding in a manner that is clear and effective? How does one make the jump from learning about individual features to thinking in Python at a deeper level? Dave Beazley's new Python Distilled addresses these and many other real-world issues.

Focusing on Python 3.6 and higher, this concise handbook focuses on the essential core of the language, with updated code examples to illuminate how Python works and how to structure programs that can be more easily explained, tested, and debugged. Throughout, Beazley reflects all he's learned teaching Python to scientists, engineers, and developers, and pushing the envelope of what makes Python tick.

Rather than trying to cover every possible feature and quirk of a 30-year-old language, this pragmatic guide provides a concise narrative related to fundamental programming topics such as data abstraction, control flow, program structure, functions, objects, and modules--topics that form the foundation for Python projects of any size.

  • Explore Python's core, from variables to packages

  • Solve data manipulation and analysis problems more effectively

  • Structure programs with an eye towards clarity and reliability

  • Control objects and master the "protocols" that define their behavior

  • Master functions and functional programming idioms

  • Discover the surprising power offered by generators

  • Understand classes from both high-level and technical perspectives

  • Plan for project growth by understanding modules and packages

  • Learn techniques and abstractions for proper I/O handling

  • Dicts!

Table of Contents

  1. Cover Page
  2. About This eBook
  3. Halftitle Page
  4. Title Page
  5. Copyright Page
  6. Contents
  7. Preface
  8. 1. Python Basics
    1. 1.1 Running Python
    2. 1.2 Python Programs
    3. 1.3 Primitives, Variables, and Expressions
    4. 1.4 Arithmetic Operators
    5. 1.5 Conditionals and Control Flow
    6. 1.6 Text Strings
    7. 1.7 File Input and Output
    8. 1.8 Lists
    9. 1.9 Tuples
    10. 1.10 Sets
    11. 1.11 Dictionaries
    12. 1.12 Iteration and Looping
    13. 1.13 Functions
    14. 1.14 Exceptions
    15. 1.15 Program Termination
    16. 1.16 Objects and Classes
    17. 1.17 Modules
    18. 1.18 Script Writing
    19. 1.19 Packages
    20. 1.20 Structuring an Application
    21. 1.21 Managing Third-Party Packages
    22. 1.22 Python: It Fits Your Brain
  9. 2. Operators, Expressions, and Data Manipulation
    1. 2.1 Literals
    2. 2.2 Expressions and Locations
    3. 2.3 Standard Operators
    4. 2.4 In-Place Assignment
    5. 2.5 Object Comparison
    6. 2.6 Ordered Comparison Operators
    7. 2.7 Boolean Expressions and Truth Values
    8. 2.8 Conditional Expressions
    9. 2.9 Operations Involving Iterables
    10. 2.10 Operations on Sequences
    11. 2.11 Operations on Mutable Sequences
    12. 2.12 Operations on Sets
    13. 2.13 Operations on Mappings
    14. 2.14 List, Set, and Dictionary Comprehensions
    15. 2.15 Generator Expressions
    16. 2.16 The Attribute (.) Operator
    17. 2.17 The Function Call () Operator
    18. 2.18 Order of Evaluation
    19. 2.19 Final Words: The Secret Life of Data
  10. 3. Program Structure and Control Flow
    1. 3.1 Program Structure and Execution
    2. 3.2 Conditional Execution
    3. 3.3 Loops and Iteration
    4. 3.4 Exceptions
    5. 3.5 Context Managers and the with Statement
    6. 3.6 Assertions and __debug__
    7. 3.7 Final Words
  11. 4. Objects, Types, and Protocols
    1. 4.1 Essential Concepts
    2. 4.2 Object Identity and Type
    3. 4.3 Reference Counting and Garbage Collection
    4. 4.4 References and Copies
    5. 4.5 Object Representation and Printing
    6. 4.6 First-Class Objects
    7. 4.7 Using None for Optional or Missing Data
    8. 4.8 Object Protocols and Data Abstraction
    9. 4.9 Object Protocol
    10. 4.10 Number Protocol
    11. 4.11 Comparison Protocol
    12. 4.12 Conversion Protocols
    13. 4.13 Container Protocol
    14. 4.14 Iteration Protocol
    15. 4.15 Attribute Protocol
    16. 4.16 Function Protocol
    17. 4.17 Context Manager Protocol
    18. 4.18 Final Words: On Being Pythonic
  12. 5. Functions
    1. 5.1 Function Definitions
    2. 5.2 Default Arguments
    3. 5.3 Variadic Arguments
    4. 5.4 Keyword Arguments
    5. 5.5 Variadic Keyword Arguments
    6. 5.6 Functions Accepting All Inputs
    7. 5.7 Positional-Only Arguments
    8. 5.8 Names, Documentation Strings, and Type Hints
    9. 5.9 Function Application and Parameter Passing
    10. 5.10 Return Values
    11. 5.11 Error Handling
    12. 5.12 Scoping Rules
    13. 5.13 Recursion
    14. 5.14 The lambda Expression
    15. 5.15 Higher-Order Functions
    16. 5.16 Argument Passing in Callback Functions
    17. 5.17 Returning Results from Callbacks
    18. 5.18 Decorators
    19. 5.19 Map, Filter, and Reduce
    20. 5.20 Function Introspection, Attributes, and Signatures
    21. 5.21 Environment Inspection
    22. 5.22 Dynamic Code Execution and Creation
    23. 5.23 Asynchronous Functions and await
    24. 5.24 Final Words: Thoughts on Functions and Composition
  13. 6. Generators
    1. 6.1 Generators and yield
    2. 6.2 Restartable Generators
    3. 6.3 Generator Delegation
    4. 6.4 Using Generators in Practice
    5. 6.5 Enhanced Generators and yield Expressions
    6. 6.6 Applications of Enhanced Generators
    7. 6.7 Generators and the Bridge to Awaiting
    8. 6.8 Final Words: A Brief History of Generators and Looking Forward
  14. 7. Classes and Object-Oriented Programming
    1. 7.1 Objects
    2. 7.2 The class Statement
    3. 7.3 Instances
    4. 7.4 Attribute Access
    5. 7.5 Scoping Rules
    6. 7.6 Operator Overloading and Protocols
    7. 7.7 Inheritance
    8. 7.8 Avoiding Inheritance via Composition
    9. 7.9 Avoiding Inheritance via Functions
    10. 7.10 Dynamic Binding and Duck Typing
    11. 7.11 The Danger of Inheriting from Built-in Types
    12. 7.12 Class Variables and Methods
    13. 7.13 Static Methods
    14. 7.14 A Word about Design Patterns
    15. 7.15 Data Encapsulation and Private Attributes
    16. 7.16 Type Hinting
    17. 7.17 Properties
    18. 7.18 Types, Interfaces, and Abstract Base Classes
    19. 7.19 Multiple Inheritance, Interfaces, and Mixins
    20. 7.20 Type-Based Dispatch
    21. 7.21 Class Decorators
    22. 7.22 Supervised Inheritance
    23. 7.23 The Object Life Cycle and Memory Management
    24. 7.24 Weak References
    25. 7.25 Internal Object Representation and Attribute Binding
    26. 7.26 Proxies, Wrappers, and Delegation
    27. 7.27 Reducing Memory Use with __slots__
    28. 7.28 Descriptors
    29. 7.29 Class Definition Process
    30. 7.30 Dynamic Class Creation
    31. 7.31 Metaclasses
    32. 7.32 Built-in Objects for Instances and Classes
    33. 7.33 Final Words: Keep It Simple
  15. 8. Modules and Packages
    1. 8.1 Modules and the import Statement
    2. 8.2 Module Caching
    3. 8.3 Importing Selected Names from a Module
    4. 8.4 Circular Imports
    5. 8.5 Module Reloading and Unloading
    6. 8.6 Module Compilation
    7. 8.7 The Module Search Path
    8. 8.8 Execution as the Main Program
    9. 8.9 Packages
    10. 8.10 Imports Within a Package
    11. 8.11 Running a Package Submodule as a Script
    12. 8.12 Controlling the Package Namespace
    13. 8.13 Controlling Package Exports
    14. 8.14 Package Data
    15. 8.15 Module Objects
    16. 8.16 Deploying Python Packages
    17. 8.17 The Penultimate Word: Start with a Package
    18. 8.18 The Final Word: Keep It Simple
  16. 9. Input and Output
    1. 9.1 Data Representation
    2. 9.2 Text Encoding and Decoding
    3. 9.3 Text and Byte Formatting
    4. 9.4 Reading Command-Line Options
    5. 9.5 Environment Variables
    6. 9.6 Files and File Objects
    7. 9.7 I/O Abstraction Layers
    8. 9.8 Standard Input, Output, and Error
    9. 9.9 Directories
    10. 9.10 The print() function
    11. 9.11 Generating Output
    12. 9.12 Consuming Input
    13. 9.13 Object Serialization
    14. 9.14 Blocking Operations and Concurrency
    15. 9.15 Standard Library Modules
    16. 9.15.25 threading Module
    17. 9.16 Final Words
  17. 10. Built-in Functions and Standard Library
    1. 10.1 Built-in Functions
    2. 10.2 Built-in Exceptions
    3. 10.3 Standard Library
    4. 10.4 Final Words: Use the Built-Ins
  18. Index
  19. Code Snippets
34.239.170.244