Read Python 3.7 documentation

[yaobinwen]

Python is the programming language I use frequently in my daily work. Therefore, it makes more sense to put its learning to a higher priority.

The documentation is here. Pick the version 3.7.

I'm going to read through three parts:

• Tutorial
• Library Reference
• Language Reference

However, I do not plan to read sequentially but on a needed base. For example, the language reference provides a lot of insight details that I have never learned systematically, and I'll probably start with that first.

I may not read the library reference that carefully but skim to see what libraries are available, and will come back when I need to look into one.

[yaobinwen]

Language Reference

• [x] 1. Introduction
  • [x] 1.1. Alternate Implementations
  • [x] 1.2. Notation
• [x] 2. Lexical analysis
  • [x] 2.1. Line structure
  • [x] 2.2. Other tokens
  • [x] 2.3. Identifiers and keywords
  • [x] 2.4. Literals
  • [x] 2.5. Operators
  • [x] 2.6. Delimiters
• [ ] 3. Data model
  • [x] 3.1. Objects, values and types
  • [x] 3.2. The standard type hierarchy
  • [ ] 3.3. Special method names
  • [ ] 3.4. Coroutines
• [ ] 4. Execution model
  • [ ] 4.1. Structure of a program
  • [ ] 4.2. Naming and binding
  • [ ] 4.3. Exceptions
• [ ] 5. The import system
  • [ ] 5.1. importlib
  • [ ] 5.2. Packages
  • [ ] 5.3. Searching
  • [ ] 5.4. Loading
  • [ ] 5.5. The Path Based Finder
  • [ ] 5.6. Replacing the standard import system
  • [ ] 5.7. Special considerations for main
  • [ ] 5.8. Open issues
  • [ ] 5.9. References
• [ ] 6. Expressions
  • [ ] 6.1. Arithmetic conversions
  • [ ] 6.2. Atoms
  • [ ] 6.3. Primaries
  • [ ] 6.4. Await expression
  • [ ] 6.5. The power operator
  • [ ] 6.6. Unary arithmetic and bitwise operations
  • [ ] 6.7. Binary arithmetic operations
  • [ ] 6.8. Shifting operations
  • [ ] 6.9. Binary bitwise operations
  • [ ] 6.10. Comparisons
  • [ ] 6.11. Boolean operations
  • [ ] 6.12. Conditional expressions
  • [ ] 6.13. Lambdas
  • [ ] 6.14. Expression lists
  • [ ] 6.15. Evaluation order
  • [ ] 6.16. Operator precedence
• [ ] 7. Simple statements
  • [ ] 7.1. Expression statements
  • [ ] 7.2. Assignment statements
  • [ ] 7.3. The assert statement
  • [ ] 7.4. The pass statement
  • [ ] 7.5. The del statement
  • [ ] 7.6. The return statement
  • [ ] 7.7. The yield statement
  • [ ] 7.8. The raise statement
  • [ ] 7.9. The break statement
  • [ ] 7.10. The continue statement
  • [ ] 7.11. The import statement
  • [ ] 7.12. The global statement
  • [ ] 7.13. The nonlocal statement
• [ ] 8. Compound statements
  • [ ] 8.1. The if statement
  • [ ] 8.2. The while statement
  • [ ] 8.3. The for statement
  • [ ] 8.4. The try statement
  • [ ] 8.5. The with statement
  • [ ] 8.6. Function definitions
  • [ ] 8.7. Class definitions
  • [ ] 8.8. Coroutines
• [ ] 9. Top-level components
  • [ ] 9.1. Complete Python programs
  • [ ] 9.2. File input
  • [ ] 9.3. Interactive input
  • [ ] 9.4. Expression input
• [ ] 10. Full Grammar specification

[yaobinwen]

Tutorial

• [x] 1. Whetting Your Appetite
• [x] 2. Using the Python Interpreter
  • [x] 2.1. Invoking the Interpreter
  • [x] 2.1.1. Argument Passing
  • [x] 2.1.2. Interactive Mode
  • [x] 2.2. The Interpreter and Its Environment
  • [x] 2.2.1. Source Code Encoding
• [x] 3. An Informal Introduction to Python
  • [x] 3.1. Using Python as a Calculator
  • [x] 3.1.1. Numbers
  • [x] 3.1.2. Strings
  • [x] 3.1.3. Lists
  • [x] 3.2. First Steps Towards Programming
• [x] 4. More Control Flow Tools
  • [x] 4.1. if Statements
  • [x] 4.2. for Statements
  • [x] 4.3. The range() Function
  • [x] 4.4. break and continue Statements, and else Clauses on Loops
  • [x] 4.5. pass Statements
  • [x] 4.6. Defining Functions
  • [x] 4.7. More on Defining Functions
  • [x] 4.7.1. Default Argument Values
  • [x] 4.7.2. Keyword Arguments
  • [x] 4.7.3. Arbitrary Argument Lists
  • [x] 4.7.4. Unpacking Argument Lists
  • [x] 4.7.5. Lambda Expressions
  • [x] 4.7.6. Documentation Strings
  • [x] 4.7.7. Function Annotations
  • [x] 4.8. Intermezzo: Coding Style
• [x] 5. Data Structures
  • [x] 5.1. More on Lists
  • [x] 5.1.1. Using Lists as Stacks
  • [x] 5.1.2. Using Lists as Queues
  • [x] 5.1.3. List Comprehensions
  • [x] 5.1.4. Nested List Comprehensions
  • [x] 5.2. The del statement
  • [x] 5.3. Tuples and Sequences
  • [x] 5.4. Sets
  • [x] 5.5. Dictionaries
  • [x] 5.6. Looping Techniques
  • [x] 5.7. More on Conditions
  • [x] 5.8. Comparing Sequences and Other Types
• [x] 6. Modules
  • [x] 6.1. More on Modules
  • [x] 6.1.1. Executing modules as scripts
  • [x] 6.1.2. The Module Search Path
  • [x] 6.1.3. “Compiled” Python files
  • [x] 6.2. Standard Modules
  • [x] 6.3. The dir() Function
  • [x] 6.4. Packages
  • [x] 6.4.1. Importing * From a Package
  • [x] 6.4.2. Intra-package References
  • [x] 6.4.3. Packages in Multiple Directories
• [x] 7. Input and Output
  • [x] 7.1. Fancier Output Formatting
  • [x] 7.1.1. Formatted String Literals
  • [x] 7.1.2. The String format() Method
  • [x] 7.1.3. Manual String Formatting
  • [x] 7.1.4. Old string formatting
  • [x] 7.2. Reading and Writing Files
  • [x] 7.2.1. Methods of File Objects
  • [x] 7.2.2. Saving structured data with json
• [x] 8. Errors and Exceptions
  • [x] 8.1. Syntax Errors
  • [x] 8.2. Exceptions
  • [x] 8.3. Handling Exceptions
  • [x] 8.4. Raising Exceptions
  • [x] 8.5. User-defined Exceptions
  • [x] 8.6. Defining Clean-up Actions
  • [x] 8.7. Predefined Clean-up Actions
• [x] 9. Classes
  • [x] 9.1. A Word About Names and Objects
  • [x] 9.2. Python Scopes and Namespaces
  • [x] 9.2.1. Scopes and Namespaces Example
  • [x] 9.3. A First Look at Classes
  • [x] 9.3.1. Class Definition Syntax
  • [x] 9.3.2. Class Objects
  • [x] 9.3.3. Instance Objects
  • [x] 9.3.4. Method Objects
  • [x] 9.3.5. Class and Instance Variables
  • [x] 9.4. Random Remarks
  • [x] 9.5. Inheritance
  • [x] 9.5.1. Multiple Inheritance
  • [x] 9.6. Private Variables
  • [x] 9.7. Odds and Ends
  • [x] 9.8. Iterators
  • [x] 9.9. Generators
  • [x] 9.10. Generator Expressions
• [x] 10. Brief Tour of the Standard Library
  • [x] 10.1. Operating System Interface
  • [x] 10.2. File Wildcards
  • [x] 10.3. Command Line Arguments
  • [x] 10.4. Error Output Redirection and Program Termination
  • [x] 10.5. String Pattern Matching
  • [x] 10.6. Mathematics
  • [x] 10.7. Internet Access
  • [x] 10.8. Dates and Times
  • [x] 10.9. Data Compression
  • [x] 10.10. Performance Measurement
  • [x] 10.11. Quality Control
  • [x] 10.12. Batteries Included
• [x] 11. Brief Tour of the Standard Library — Part II
  • [x] 11.1. Output Formatting
  • [x] 11.2. Templating
  • [x] 11.3. Working with Binary Data Record Layouts
  • [x] 11.4. Multi-threading
  • [x] 11.5. Logging
  • [x] 11.6. Weak References
  • [x] 11.7. Tools for Working with Lists
  • [x] 11.8. Decimal Floating Point Arithmetic
• [x] 12. Virtual Environments and Packages
  • [x] 12.1. Introduction
  • [x] 12.2. Creating Virtual Environments
  • [x] 12.3. Managing Packages with pip
• [ ] 13. What Now?
• [ ] 14. Interactive Input Editing and History Substitution
  • [ ] 14.1. Tab Completion and History Editing
  • [ ] 14.2. Alternatives to the Interactive Interpreter
• [x] 15. Floating Point Arithmetic: Issues and Limitations
  • [x] 15.1. Representation Error
• [ ] 16. Appendix
  • [ ] 16.1. Interactive Mode
  • [ ] 16.1.1. Error Handling
  • [ ] 16.1.2. Executable Python Scripts
  • [ ] 16.1.3. The Interactive Startup File
  • [ ] 16.1.4. The Customization Modules

[yaobinwen]

I still need to learn the following specific Python topics:

• [ ] Magic methods
• [ ] Class inheritance and mix-in
• [ ] Context manager
• [ ] Generator
• [ ] Asynchronicity and concurrency