High Performance Python. 3rd Edition Micha Gorelick, Ian Ozsvald

Spis treści książki

• Foreword
• Preface
  • Who This Book Is For
  • Who This Book Is Not For
  • What Youll Learn
  • Python 3
  • License
  • How to Make an Attribution
  • Using Code Examples
  • Errata and Feedback
  • Conventions Used in This Book
  • OReilly Online Learning
  • How to Contact Us
  • Acknowledgments
• 1. Understanding Performant Python
  • The Fundamental Computer System
    • Computing Units
    • Memory Units
    • Communications Layers
  • Idealized Computing Versus the Python Virtual Machine
    • Idealized Computing
    • Pythons Virtual Machine
  • So Why Use Python?
  • How to Be a Highly Performant Programmer
    • Good Working Practices
    • Optimizing for the Team Rather than the Code Block
    • The Remote Performant Programmer
    • Some Thoughts on Good Notebook Practice
    • Your Work
  • The Future of Python
    • Where Did the GIL Go?
    • Does Python Have a JIT?
  • Wrap-Up
• 2. Profiling to Find Bottlenecks
  • Profiling Efficiently
  • Introducing the Julia Set
  • Calculating the Full Julia Set
  • Simple Approaches to Timingprint and a Decorator
  • Simple Timing Using the Unix time Command
  • Using the cProfile Module
  • Visualizing cProfile Output with SnakeViz
  • Using line_profiler for Line-by-Line Measurements
  • Using memory_profiler to Diagnose Memory Usage
  • Combining CPU and Memory Profiling with Scalene
  • Introspecting an Existing Process with PySpy
  • VizTracer for an Interactive Time-Based Call Stack
  • Bytecode: Under the Hood
    • Using the dis Module to Examine CPython Bytecode
    • Digging into Bytecode Specialization with Specialist
    • Different Approaches, Different Complexity
  • Unit Testing During Optimization to Maintain Correctness
    • No-op @profile Decorator
  • Strategies to Profile Your Code Successfully
  • Wrap-Up
• 3. Lists and Tuples
  • A More Efficient Search
  • Lists Versus Tuples
    • Lists as Dynamic Arrays
    • Tuples as Static Arrays
  • Wrap-Up
• 4. Dictionaries and Sets
  • How Do Dictionaries and Sets Work?
    • Inserting and Retrieving
    • Deletion
    • Resizing
    • Hash Functions and Entropy
  • Wrap-Up
• 5. Iterators and Generators
  • Iterators for Infinite Series
  • Lazy Generator Evaluation
  • Wrap-Up
• 6. Matrix and Vector Computation
  • Introduction to the Problem
  • Arent Python Lists Good Enough?
    • Problems with Allocating Too Much
  • Memory Fragmentation
    • Understanding perf
    • Making Decisions with perfs Output
    • Enter numpy
  • Applying numpy to the Diffusion Problem
    • Memory Allocations and In-Place Operations
    • Selective Optimizations: Finding What Needs to Be Fixed
  • numexpr: Making In-Place Operations Faster and Easier
  • Graphics Processing Units (GPUs)
    • Dynamic Graphs: PyTorch
    • GPU Speed and Numerical Precision
    • GPU-Specific Operations
    • Basic GPU Profiling
    • Performance Considerations of GPUs
    • When to Use GPUs
    • Deep Learning Performance Considerations
      • Automatic Mixed-Precision
      • Model quantization
      • Model or data distribution
      • JIT
  • A Cautionary Tale: Verify Optimizations (scipy)
  • Lessons from Matrix Optimizations
  • Wrap-Up
• 7. Pandas, Dask, and Polars
  • Pandas
    • Pandass Internal Model
    • Arrow and NumPy
    • Applying a Function to Many Rows of Data
      • Which OLS implementation should we use?
      • Applying lstsq to our rows of data
    • Numba to Compile NumPy for Pandas
    • Building from Partial Results Rather than Concatenating
    • Theres More Than One (and Possibly a Faster) Way to Do a Job
    • Advice for Effective Pandas Development
  • Dask for Distributed Data Structures and DataFrames
    • Diagnostics
    • Parallel Pandas with Dask
      • Dask Expressions
      • Parallelized computations
    • Parallelized apply with Swifter on Dask
  • Polars for Fast DataFrames
  • Wrap-Up
• 8. Compiling to C
  • What Sort of Speed Gains Are Possible?
  • JIT Versus AOT Compilers
  • Why Does Type Information Help the Code Run Faster?
  • Using a C Compiler
  • Reviewing the Julia Set Example
  • Cython
    • Compiling a Pure Python Version Using Cython
  • pyximport
    • Cython Annotations to Analyze a Block of Code
    • Adding Some Type Annotations
  • Cython and numpy
    • Parallelizing the Solution with OpenMP on One Machine
  • Numba
  • PyPy
    • Garbage Collection Differences
    • Running PyPy and Installing Modules
  • A Summary of Speed Improvements
  • When to Use Each Technology
  • Foreign Function Interfaces
    • ctypes
    • cffi
    • f2py
    • CPython Extensions: C
    • CPython Extensions: Rust
      • Creating a Python extension with Rust
      • Writing the extension
      • Installing and using the extension
  • Wrap-Up
• 9. Asynchronous I/O
  • Introduction to Asynchronous Programming
  • How Does async/await Work?
    • Serial Web Crawler
    • Asynchronous Web Crawler
  • Shared CPUI/O Workload
    • Serial CPU Workload
    • Batched CPU Workload
    • Fully Asynchronous CPU Workload
  • Wrap-Up
• 10. The multiprocessing Module
  • An Overview of the multiprocessing Module
  • Estimating Pi Using the Monte Carlo Method
  • Estimating Pi Using Processes and Threads
    • Using Python Objects
    • Replacing multiprocessing with Joblib
      • Intelligent caching of function call results
    • Random Numbers in Parallel Systems
    • Using numpy
  • Finding Prime Numbers
    • Queues of Work
    • Asynchronously Adding Jobs to the Queue
  • Verifying Primes Using Interprocess Communication
    • Serial Solution
    • Naive Pool Solution
    • A Less Naive Pool Solution
    • Using manager.Value as a Flag
    • Using Redis as a Flag
    • Using RawValue as a Flag
    • Using mmap as a Flag
    • Using mmap as a Flag Redux
  • Sharing numpy Data with multiprocessing
  • Synchronizing File and Variable Access
    • File Locking
    • Locking a Value
  • Wrap-Up
• 11. Clusters and Job Queues
  • Benefits of Clustering
  • Drawbacks of Clustering
    • $462 Million Wall Street Loss Through Poor Cluster Upgrade Strategy
    • Skypes 24-Hour Global Outage
  • Common Cluster Designs
  • How to Start a Clustered Solution
  • Ways to Avoid Pain When Using Clusters
  • Two Clustering Solutions
    • Using IPython Parallel to Support Research
    • Message Brokering for Cluster Efficiency
      • Queue
      • Pub/sub
  • Other Clustering Tools to Look At
  • Docker
    • Dockers Performance
    • Advantages of Docker
  • Wrap-Up
• 12. Using Less RAM
  • Objects for Primitives Are Expensive
    • The array Module Stores Many Primitive Objects Cheaply
    • Using Less RAM in NumPy with NumExpr
  • Understanding the RAM Used in a Collection
  • Bytes Versus Unicode
  • Efficiently Storing Lots of Text in RAM
    • Trying These Approaches on 11 Million Tokens
      • list
      • set
      • dict
      • More efficient tree structures
      • Marisa trie
      • Using tries in production systems
  • Modeling More Text with scikit-learns FeatureHasher
  • Introducing DictVectorizer and FeatureHasher
    • Comparing DictVectorizer and FeatureHasher on a Real Problem
  • SciPys Sparse Matrices
  • Tips for Using Less RAM
  • Probabilistic Data Structures
    • Very Approximate Counting with a 1-Byte Morris Counter
    • K-Minimum Values
    • Bloom Filters
    • LogLog Counter
    • Real-World Example
  • Wrap-Up
• 13. Lessons from the Field
  • Developing a High Performance Machine Learning Algorithm
  • High Performance Computing in Journalism
  • Lessons from the Field of Cyber Reinsurance
  • Python in Quant Finance
  • Maintain Flexibility to Achieve High Performance
  • Streamlining Feature Engineering Pipelines with Feature-engine (2020)
  • Highly Performant Data Science Teams (2020)
  • Numba (2020)
  • Optimizing Versus Thinking (2020)
  • Making Deep Learning Fly with RadimRehurek.com (2014)
  • Large-Scale Social Media Analysis at Smesh (2014)
• Index

pokaż cały spis treści

ukryj recenzje